1// Copyright 2020 The Pigweed Authors
2//
3// Licensed under the Apache License, Version 2.0 (the "License"); you may not
4// use this file except in compliance with the License. You may obtain a copy of
5// the License at
6//
7//     https://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
11// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
12// License for the specific language governing permissions and limitations under
13// the License.
14#pragma once
15
16#include <algorithm>
17#include <cstddef>
18#include <iterator>
19
20#include "pw_polyfill/standard_library/namespace.h"
21
22#define __cpp_lib_string_view 201606L
23
24_PW_POLYFILL_BEGIN_NAMESPACE_STD
25
26template <typename T>
27class char_traits;
28
29template <typename T, typename = char_traits<T>>
30class basic_string_view {
31 public:
32  using traits_type = void;  // No traits object is used.
33  using value_type = T;
34  using pointer = T*;
35  using const_pointer = const T*;
36  using reference = T&;
37  using const_reference = const T&;
38  using const_iterator = const T*;
39  using iterator = const_iterator;
40  using const_reverse_iterator = ::std::reverse_iterator<const_iterator>;
41  using reverse_iterator = const_reverse_iterator;
42  using size_type = decltype(sizeof(0));
43  using difference_type = ptrdiff_t;
44
45  static constexpr size_type npos = size_type(-1);
46
47  constexpr basic_string_view() noexcept : string_(nullptr), size_(0) {}
48  constexpr basic_string_view(const basic_string_view&) noexcept = default;
49  constexpr basic_string_view(const T* string, size_type count)
50      : string_(string), size_(count) {}
51  constexpr basic_string_view(const T* string)
52      : string_(string), size_(CStringLength(string)) {}
53
54  constexpr basic_string_view& operator=(const basic_string_view&) noexcept =
55      default;
56
57  constexpr const_iterator begin() const noexcept { return string_; }
58  constexpr const_iterator cbegin() const noexcept { return begin(); }
59
60  constexpr const_iterator end() const noexcept { return string_ + size_; }
61  constexpr const_iterator cend() const noexcept { return end(); }
62
63  // NOT IMPLEMENTED: Reverse iterators not supported.
64  constexpr const_reverse_iterator rbegin() const noexcept;
65  constexpr const_reverse_iterator crbegin() const noexcept;
66
67  constexpr const_reverse_iterator rend() const noexcept;
68  constexpr const_reverse_iterator crend() const noexcept;
69
70  constexpr const_reference operator[](size_type pos) const {
71    return data()[pos];
72  }
73
74  // NOT IMPLEMENTED: at() has no bounds checking.
75  constexpr const_reference at(size_type pos) const { return data()[pos]; }
76
77  constexpr const_reference front() const { return data()[0]; }
78
79  constexpr const_reference back() const { return data()[size() - 1]; }
80
81  constexpr const_pointer data() const noexcept { return string_; }
82
83  constexpr size_type size() const noexcept { return size_; }
84  constexpr size_type length() const noexcept { return size(); }
85
86  constexpr size_type max_size() const noexcept { return ~size_type{0}; }
87
88  [[nodiscard]] constexpr bool empty() const noexcept { return size() == 0u; }
89
90  constexpr void remove_prefix(size_type characters) {
91    string_ += characters;
92    size_ -= characters;
93  }
94
95  constexpr void remove_suffix(size_type characters) { size_ -= characters; }
96
97  constexpr void swap(basic_string_view& other) noexcept {
98    pointer temp_string = string_;
99    string_ = other.string_;
100    other.string_ = temp_string;
101
102    size_type temp_size = size_;
103    size_ = other.size_;
104    other.size_ = temp_size;
105  }
106
107  // NOT IMPLEMENTED: copy does no bounds checking.
108  constexpr size_type copy(T* dest, size_type count, size_type pos = 0) const {
109    const size_type to_copy = min(count, size() - pos);
110    for (size_type i = pos; i < pos + to_copy; ++i) {
111      *dest++ = string_[i];
112    }
113    return to_copy;
114  }
115
116  constexpr basic_string_view substr(size_type pos = 0,
117                                     size_type count = npos) const {
118    return basic_string_view(string_ + pos, min(count, size() - pos));
119  }
120
121  // NOT IMPLEMENTED: These functions and their overloads are not defined.
122  constexpr int compare(basic_string_view view) const noexcept;
123  constexpr bool starts_with(basic_string_view view) const noexcept;
124  constexpr bool ends_with(basic_string_view view) const noexcept;
125  constexpr size_type find(basic_string_view view,
126                           size_type pos = 0) const noexcept;
127  constexpr size_type rfind(basic_string_view view,
128                            size_type pos = npos) const noexcept;
129  constexpr size_type find_first_of(basic_string_view view,
130                                    size_type pos = 0) const noexcept;
131  constexpr size_type find_last_of(basic_string_view view,
132                                   size_type pos = npos) const noexcept;
133  constexpr size_type find_first_not_of(basic_string_view view,
134                                        size_type pos = 0) const noexcept;
135  constexpr size_type find_last_not_of(basic_string_view view,
136                                       size_type pos = npos) const noexcept;
137
138 private:
139  static constexpr size_type CStringLength(const T* string) {
140    size_type length = 0;
141    while (string[length] != T()) {
142      length += 1;
143    }
144    return length;
145  }
146
147  const_pointer string_;
148  size_type size_;
149};
150
151template <typename T>
152constexpr bool operator==(basic_string_view<T> lhs, basic_string_view<T> rhs) {
153  if (lhs.size() != rhs.size()) {
154    return false;
155  }
156  for (typename basic_string_view<T>::size_type i = 0; i < lhs.size(); ++i) {
157    if (lhs[i] != rhs[i]) {
158      return false;
159    }
160  }
161  return true;
162}
163
164template <typename T>
165constexpr bool operator!=(basic_string_view<T> lhs, basic_string_view<T> rhs) {
166  return !(lhs == rhs);
167}
168
169// NOT IMPLEMENTED: Other comparison operators are not defined.
170
171using string_view = basic_string_view<char>;
172using wstring_view = basic_string_view<wchar_t>;
173using u16string_view = basic_string_view<char16_t>;
174using u32string_view = basic_string_view<char32_t>;
175
176// NOT IMPLEMENTED: string_view literals cannot be implemented since they do not
177//                  start with _.
178
179_PW_POLYFILL_END_NAMESPACE_STD
180