string_view.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2019-2023, 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 <cuda_runtime.h>
 
#include <iterator>
 
namespace cudf {
 
using char_utf8 = uint32_t;  
 
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 char const* 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(string_view const& str, size_type pos);
    const_iterator(const_iterator const& mit)        = default;
    const_iterator(const_iterator&& mit)             = default;
    const_iterator& operator=(const_iterator const&) = 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) const;
    __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) const;
    __device__ inline const_iterator& move_to(size_type);
    __device__ inline bool operator==(const_iterator const&) const;
    __device__ inline bool operator!=(const_iterator const&) const;
    __device__ inline bool operator<(const_iterator const&) const;
    __device__ inline bool operator<=(const_iterator const&) const;
    __device__ inline bool operator>(const_iterator const&) const;
    __device__ inline bool operator>=(const_iterator const&) const;
    __device__ inline char_utf8 operator*() const;
    [[nodiscard]] __device__ inline size_type position() const;
    [[nodiscard]] __device__ inline size_type byte_offset() const;
 
   private:
    friend class string_view;
    char const* p{};
    size_type bytes{};
    size_type char_pos{};
    size_type byte_pos{};
    __device__ inline const_iterator(string_view const& str, size_type pos, size_type offset);
  };
 
  __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(string_view const& str) const;
  __device__ inline int compare(char const* str, size_type bytes) const;
 
  __device__ inline bool operator==(string_view const& rhs) const;
  __device__ inline bool operator!=(string_view const& rhs) const;
  __device__ inline bool operator<(string_view const& rhs) const;
  __device__ inline bool operator>(string_view const& rhs) const;
  __device__ inline bool operator<=(string_view const& rhs) const;
  __device__ inline bool operator>=(string_view const& rhs) const;
 
  __device__ [[nodiscard]] inline size_type find(string_view const& str,
                                                 size_type pos   = 0,
                                                 size_type count = -1) const;
  __device__ inline size_type find(char const* 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(string_view const& str,
                                                  size_type pos   = 0,
                                                  size_type count = -1) const;
  __device__ inline size_type rfind(char const* 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(char const* data, size_type bytes)
    : _data(data), _bytes(bytes), _length(UNKNOWN_STRING_LENGTH)
  {
  }
 
  string_view(string_view const&) = default;  
  string_view(string_view&&)      = default;  
  ~string_view()                  = default;
  string_view& operator=(string_view const&) = default;
  string_view& operator=(string_view&&) = default;
 
  static inline cudf::size_type const npos{-1};
 
 private:
  char const* _data{};          
  size_type _bytes{};           
  mutable size_type _length{};  
 
  static inline cudf::size_type const UNKNOWN_STRING_LENGTH{-1};
 
  __device__ [[nodiscard]] inline size_type character_offset(size_type bytepos) const;
 
  template <bool forward>
  __device__ inline size_type find_impl(char const* str,
                                        size_type bytes,
                                        size_type pos,
                                        size_type count) const;
};
 
}  // namespace cudf