string_view.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2019-2021, NVIDIA CORPORATION.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#pragma once
 
#include <cuda_runtime.h>
#include <cstddef>
#include <cudf/types.hpp>
#include <iterator>
 
namespace cudf {
 
using char_utf8 = uint32_t;  
 
constexpr cudf::size_type UNKNOWN_STRING_LENGTH{-1};
 
constexpr int8_t UNKNOWN_CHAR_WIDTH{-1};
 
constexpr int8_t VARIABLE_CHAR_WIDTH{0};
 
class string_view {
 public:
  CUDA_HOST_DEVICE_CALLABLE size_type size_bytes() const { return _bytes; }
  CUDA_DEVICE_CALLABLE size_type length() const;
  CUDA_HOST_DEVICE_CALLABLE const char* data() const { return _data; }
 
  CUDA_HOST_DEVICE_CALLABLE bool empty() const { return size_bytes() == 0; }
 
  class const_iterator {
   public:
    using difference_type   = ptrdiff_t;
    using value_type        = char_utf8;
    using reference         = char_utf8&;
    using pointer           = char_utf8*;
    using iterator_category = std::input_iterator_tag;
    CUDA_DEVICE_CALLABLE const_iterator(const string_view& str, size_type pos);
    const_iterator(const const_iterator& mit) = default;
    const_iterator(const_iterator&& mit)      = default;
    const_iterator& operator=(const const_iterator&) = default;
    const_iterator& operator=(const_iterator&&) = default;
    CUDA_DEVICE_CALLABLE const_iterator& operator++();
    CUDA_DEVICE_CALLABLE const_iterator operator++(int);
    CUDA_DEVICE_CALLABLE const_iterator& operator+=(difference_type);
    CUDA_DEVICE_CALLABLE const_iterator operator+(difference_type);
    CUDA_DEVICE_CALLABLE const_iterator& operator--();
    CUDA_DEVICE_CALLABLE const_iterator operator--(int);
    CUDA_DEVICE_CALLABLE const_iterator& operator-=(difference_type);
    CUDA_DEVICE_CALLABLE const_iterator operator-(difference_type);
    CUDA_DEVICE_CALLABLE bool operator==(const const_iterator&) const;
    CUDA_DEVICE_CALLABLE bool operator!=(const const_iterator&) const;
    CUDA_DEVICE_CALLABLE bool operator<(const const_iterator&) const;
    CUDA_DEVICE_CALLABLE bool operator<=(const const_iterator&) const;
    CUDA_DEVICE_CALLABLE bool operator>(const const_iterator&) const;
    CUDA_DEVICE_CALLABLE bool operator>=(const const_iterator&) const;
    CUDA_DEVICE_CALLABLE char_utf8 operator*() const;
    CUDA_DEVICE_CALLABLE size_type position() const;
    CUDA_DEVICE_CALLABLE size_type byte_offset() const;
 
   private:
    const char* p{};
    size_type bytes{};
    size_type char_pos{};
    size_type byte_pos{};
  };
 
  CUDA_DEVICE_CALLABLE const_iterator begin() const;
  CUDA_DEVICE_CALLABLE const_iterator end() const;
 
  CUDA_DEVICE_CALLABLE char_utf8 operator[](size_type pos) const;
  CUDA_DEVICE_CALLABLE size_type byte_offset(size_type pos) const;
 
  CUDA_DEVICE_CALLABLE int compare(const string_view& str) const;
  CUDA_DEVICE_CALLABLE int compare(const char* str, size_type bytes) const;
 
  CUDA_DEVICE_CALLABLE bool operator==(const string_view& rhs) const;
  CUDA_DEVICE_CALLABLE bool operator!=(const string_view& rhs) const;
  CUDA_DEVICE_CALLABLE bool operator<(const string_view& rhs) const;
  CUDA_DEVICE_CALLABLE bool operator>(const string_view& rhs) const;
  CUDA_DEVICE_CALLABLE bool operator<=(const string_view& rhs) const;
  CUDA_DEVICE_CALLABLE bool operator>=(const string_view& rhs) const;
 
  CUDA_DEVICE_CALLABLE size_type find(const string_view& str,
                                      size_type pos   = 0,
                                      size_type count = -1) const;
  CUDA_DEVICE_CALLABLE size_type find(const char* str,
                                      size_type bytes,
                                      size_type pos   = 0,
                                      size_type count = -1) const;
  CUDA_DEVICE_CALLABLE size_type find(char_utf8 character,
                                      size_type pos   = 0,
                                      size_type count = -1) const;
  CUDA_DEVICE_CALLABLE size_type rfind(const string_view& str,
                                       size_type pos   = 0,
                                       size_type count = -1) const;
  CUDA_DEVICE_CALLABLE size_type rfind(const char* str,
                                       size_type bytes,
                                       size_type pos   = 0,
                                       size_type count = -1) const;
  CUDA_DEVICE_CALLABLE size_type rfind(char_utf8 character,
                                       size_type pos   = 0,
                                       size_type count = -1) const;
 
  CUDA_DEVICE_CALLABLE string_view substr(size_type start, size_type length) const;
 
  CUDA_HOST_DEVICE_CALLABLE static string_view min();
 
  CUDA_HOST_DEVICE_CALLABLE static string_view max();
 
  CUDA_HOST_DEVICE_CALLABLE string_view() : _data(""), _bytes(0), _length(0), _char_width(0) {}
 
  CUDA_HOST_DEVICE_CALLABLE string_view(const char* data, size_type bytes)
    : _data(data), _bytes(bytes), _length(UNKNOWN_STRING_LENGTH), _char_width(UNKNOWN_CHAR_WIDTH)
  {
  }
 
  string_view(const string_view&) = default;
  string_view(string_view&&)      = default;
  ~string_view()                  = default;
  string_view& operator=(const string_view&) = default;
  string_view& operator=(string_view&&) = default;
 
 private:
  const char* _data{};           
  size_type _bytes{};            
  mutable size_type _length{};   
  mutable int8_t _char_width{};  
 
  CUDA_DEVICE_CALLABLE size_type character_offset(size_type bytepos) const;
};
 
namespace strings {
namespace detail {
 
constexpr bool is_begin_utf8_char(uint8_t byte)
{
  // The (0xC0 & 0x80) bit pattern identifies a continuation byte of a character.
  return (byte & 0xC0) != 0x80;
}
 
constexpr size_type bytes_in_char_utf8(char_utf8 character)
{
  return 1 + static_cast<size_type>((character & unsigned{0x0000FF00}) > 0) +
         static_cast<size_type>((character & unsigned{0x00FF0000}) > 0) +
         static_cast<size_type>((character & unsigned{0xFF000000}) > 0);
}
 
constexpr size_type bytes_in_utf8_byte(uint8_t byte)
{
  return 1 + static_cast<size_type>((byte & 0xF0) == 0xF0)  // 4-byte character prefix
         + static_cast<size_type>((byte & 0xE0) == 0xE0)    // 3-byte character prefix
         + static_cast<size_type>((byte & 0xC0) == 0xC0)    // 2-byte character prefix
         - static_cast<size_type>((byte & 0xC0) == 0x80);   // intermediate byte
}
 
CUDA_HOST_DEVICE_CALLABLE size_type to_char_utf8(const char* str, char_utf8& character)
{
  size_type const chr_width = bytes_in_utf8_byte(static_cast<uint8_t>(*str));
 
  character = static_cast<char_utf8>(*str++) & 0xFF;
  if (chr_width > 1) {
    character = character << 8;
    character |= (static_cast<char_utf8>(*str++) & 0xFF);  // << 8;
    if (chr_width > 2) {
      character = character << 8;
      character |= (static_cast<char_utf8>(*str++) & 0xFF);  // << 16;
      if (chr_width > 3) {
        character = character << 8;
        character |= (static_cast<char_utf8>(*str++) & 0xFF);  // << 24;
      }
    }
  }
  return chr_width;
}
 
CUDA_HOST_DEVICE_CALLABLE size_type from_char_utf8(char_utf8 character, char* str)
{
  size_type const chr_width = bytes_in_char_utf8(character);
  for (size_type idx = 0; idx < chr_width; ++idx) {
    str[chr_width - idx - 1] = static_cast<char>(character) & 0xFF;
    character                = character >> 8;
  }
  return chr_width;
}
 
}  // namespace detail
}  // namespace strings
}  // namespace cudf