string_view.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2019-2022, 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 <cudf/types.hpp>
 
#include <iterator>
 
namespace cudf {
 
using char_utf8 = uint32_t;  
 
constexpr cudf::size_type UNKNOWN_STRING_LENGTH{-1};
 
class string_view {
 public:
  CUDF_HOST_DEVICE [[nodiscard]] inline size_type size_bytes() const { return _bytes; }
  __device__ [[nodiscard]] inline size_type length() const;
  CUDF_HOST_DEVICE [[nodiscard]] inline const char* data() const { return _data; }
 
  CUDF_HOST_DEVICE [[nodiscard]] inline 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;
    __device__ inline 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;
    __device__ inline const_iterator& operator++();
    __device__ inline const_iterator operator++(int);
    __device__ inline const_iterator& operator+=(difference_type);
    __device__ inline const_iterator operator+(difference_type);
    __device__ inline const_iterator& operator--();
    __device__ inline const_iterator operator--(int);
    __device__ inline const_iterator& operator-=(difference_type);
    __device__ inline const_iterator operator-(difference_type);
    __device__ inline bool operator==(const const_iterator&) const;
    __device__ inline bool operator!=(const const_iterator&) const;
    __device__ inline bool operator<(const const_iterator&) const;
    __device__ inline bool operator<=(const const_iterator&) const;
    __device__ inline bool operator>(const const_iterator&) const;
    __device__ inline bool operator>=(const const_iterator&) const;
    __device__ inline char_utf8 operator*() const;
    [[nodiscard]] __device__ inline size_type position() const;
    [[nodiscard]] __device__ inline size_type byte_offset() const;
 
   private:
    const char* p{};
    size_type bytes{};
    size_type char_pos{};
    size_type byte_pos{};
  };
 
  __device__ [[nodiscard]] inline const_iterator begin() const;
  __device__ [[nodiscard]] inline const_iterator end() const;
 
  __device__ inline char_utf8 operator[](size_type pos) const;
  __device__ [[nodiscard]] inline size_type byte_offset(size_type pos) const;
 
  __device__ [[nodiscard]] inline int compare(const string_view& str) const;
  __device__ inline int compare(const char* str, size_type bytes) const;
 
  __device__ inline bool operator==(const string_view& rhs) const;
  __device__ inline bool operator!=(const string_view& rhs) const;
  __device__ inline bool operator<(const string_view& rhs) const;
  __device__ inline bool operator>(const string_view& rhs) const;
  __device__ inline bool operator<=(const string_view& rhs) const;
  __device__ inline bool operator>=(const string_view& rhs) const;
 
  __device__ [[nodiscard]] inline size_type find(const string_view& str,
                                                 size_type pos   = 0,
                                                 size_type count = -1) const;
  __device__ inline size_type find(const char* str,
                                   size_type bytes,
                                   size_type pos   = 0,
                                   size_type count = -1) const;
  __device__ [[nodiscard]] inline size_type find(char_utf8 character,
                                                 size_type pos   = 0,
                                                 size_type count = -1) const;
  __device__ [[nodiscard]] inline size_type rfind(const string_view& str,
                                                  size_type pos   = 0,
                                                  size_type count = -1) const;
  __device__ inline size_type rfind(const char* str,
                                    size_type bytes,
                                    size_type pos   = 0,
                                    size_type count = -1) const;
  __device__ [[nodiscard]] inline size_type rfind(char_utf8 character,
                                                  size_type pos   = 0,
                                                  size_type count = -1) const;
 
  __device__ [[nodiscard]] inline string_view substr(size_type start, size_type length) const;
 
  CUDF_HOST_DEVICE inline static string_view min();
 
  CUDF_HOST_DEVICE inline static string_view max();
 
  CUDF_HOST_DEVICE inline string_view() : _data("") {}
 
  CUDF_HOST_DEVICE inline string_view(const char* data, size_type bytes)
    : _data(data), _bytes(bytes), _length(UNKNOWN_STRING_LENGTH)
  {
  }
 
  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{};  
 
  __device__ [[nodiscard]] inline size_type character_offset(size_type bytepos) const;
};
 
}  // namespace cudf