contrib/libc++/include/experimental/string_view

   1 // -*- C++ -*-
   2 //===------------------------ string_view ---------------------------------===//
   3 //
   4 //                     The LLVM Compiler Infrastructure
   5 //
   6 // This file is distributed under the University of Illinois Open Source
   7 // License. See LICENSE.TXT for details.
   8 //
   9 //===----------------------------------------------------------------------===//
  10
  11 #ifndef _LIBCPP_LFTS_STRING_VIEW
  12 #define _LIBCPP_LFTS_STRING_VIEW
  13
  14 /*
  15 string_view synopsis
  16
  17 namespace std {
  18  namespace experimental {
  19   inline namespace library_fundamentals_v1 {
  20
  21     // 7.2, Class template basic_string_view
  22     template<class charT, class traits = char_traits<charT>>
  23         class basic_string_view;
  24
  25     // 7.9, basic_string_view non-member comparison functions
  26     template<class charT, class traits>
  27     constexpr bool operator==(basic_string_view<charT, traits> x,
  28                               basic_string_view<charT, traits> y) noexcept;
  29     template<class charT, class traits>
  30     constexpr bool operator!=(basic_string_view<charT, traits> x,
  31                               basic_string_view<charT, traits> y) noexcept;
  32     template<class charT, class traits>
  33     constexpr bool operator< (basic_string_view<charT, traits> x,
  34                                  basic_string_view<charT, traits> y) noexcept;
  35     template<class charT, class traits>
  36     constexpr bool operator> (basic_string_view<charT, traits> x,
  37                               basic_string_view<charT, traits> y) noexcept;
  38     template<class charT, class traits>
  39     constexpr bool operator<=(basic_string_view<charT, traits> x,
  40                                  basic_string_view<charT, traits> y) noexcept;
  41     template<class charT, class traits>
  42     constexpr bool operator>=(basic_string_view<charT, traits> x,
  43                               basic_string_view<charT, traits> y) noexcept;
  44     // see below, sufficient additional overloads of comparison functions
  45
  46     // 7.10, Inserters and extractors
  47     template<class charT, class traits>
  48       basic_ostream<charT, traits>&
  49         operator<<(basic_ostream<charT, traits>& os,
  50                    basic_string_view<charT, traits> str);
  51
  52     // basic_string_view typedef names
  53     typedef basic_string_view<char> string_view;
  54     typedef basic_string_view<char16_t> u16string_view;
  55     typedef basic_string_view<char32_t> u32string_view;
  56     typedef basic_string_view<wchar_t> wstring_view;
  57
  58     template<class charT, class traits = char_traits<charT>>
  59     class basic_string_view {
  60       public:
  61       // types
  62       typedef traits traits_type;
  63       typedef charT value_type;
  64       typedef charT* pointer;
  65       typedef const charT* const_pointer;
  66       typedef charT& reference;
  67       typedef const charT& const_reference;
  68       typedef implementation-defined const_iterator;
  69       typedef const_iterator iterator;
  70       typedef reverse_iterator<const_iterator> const_reverse_iterator;
  71       typedef const_reverse_iterator reverse_iterator;
  72       typedef size_t size_type;
  73       typedef ptrdiff_t difference_type;
  74       static constexpr size_type npos = size_type(-1);
  75
  76       // 7.3, basic_string_view constructors and assignment operators
  77       constexpr basic_string_view() noexcept;
  78       constexpr basic_string_view(const basic_string_view&) noexcept = default;
  79       basic_string_view& operator=(const basic_string_view&) noexcept = default;
  80       template<class Allocator>
  81       basic_string_view(const basic_string<charT, traits, Allocator>& str) noexcept;
  82       constexpr basic_string_view(const charT* str);
  83       constexpr basic_string_view(const charT* str, size_type len);
  84
  85       // 7.4, basic_string_view iterator support
  86       constexpr const_iterator begin() const noexcept;
  87       constexpr const_iterator end() const noexcept;
  88       constexpr const_iterator cbegin() const noexcept;
  89       constexpr const_iterator cend() const noexcept;
  90       const_reverse_iterator rbegin() const noexcept;
  91       const_reverse_iterator rend() const noexcept;
  92       const_reverse_iterator crbegin() const noexcept;
  93       const_reverse_iterator crend() const noexcept;
  94
  95       // 7.5, basic_string_view capacity
  96       constexpr size_type size() const noexcept;
  97       constexpr size_type length() const noexcept;
  98       constexpr size_type max_size() const noexcept;
  99       constexpr bool empty() const noexcept;
 100
 101       // 7.6, basic_string_view element access
 102       constexpr const_reference operator[](size_type pos) const;
 103       constexpr const_reference at(size_type pos) const;
 104       constexpr const_reference front() const;
 105       constexpr const_reference back() const;
 106       constexpr const_pointer data() const noexcept;
 107
 108       // 7.7, basic_string_view modifiers
 109       constexpr void clear() noexcept;
 110       constexpr void remove_prefix(size_type n);
 111       constexpr void remove_suffix(size_type n);
 112       constexpr void swap(basic_string_view& s) noexcept;
 113
 114       // 7.8, basic_string_view string operations
 115       template<class Allocator>
 116       explicit operator basic_string<charT, traits, Allocator>() const;
 117       template<class Allocator = allocator<charT>>
 118       basic_string<charT, traits, Allocator> to_string(
 119         const Allocator& a = Allocator()) const;
 120
 121       size_type copy(charT* s, size_type n, size_type pos = 0) const;
 122
 123       constexpr basic_string_view substr(size_type pos = 0, size_type n = npos) const;
 124       constexpr int compare(basic_string_view s) const noexcept;
 125       constexpr int compare(size_type pos1, size_type n1, basic_string_view s) const;
 126       constexpr int compare(size_type pos1, size_type n1,
 127                             basic_string_view s, size_type pos2, size_type n2) const;
 128       constexpr int compare(const charT* s) const;
 129       constexpr int compare(size_type pos1, size_type n1, const charT* s) const;
 130       constexpr int compare(size_type pos1, size_type n1,
 131                             const charT* s, size_type n2) const;
 132       constexpr size_type find(basic_string_view s, size_type pos = 0) const noexcept;
 133       constexpr size_type find(charT c, size_type pos = 0) const noexcept;
 134       constexpr size_type find(const charT* s, size_type pos, size_type n) const;
 135       constexpr size_type find(const charT* s, size_type pos = 0) const;
 136       constexpr size_type rfind(basic_string_view s, size_type pos = npos) const noexcept;
 137       constexpr size_type rfind(charT c, size_type pos = npos) const noexcept;
 138       constexpr size_type rfind(const charT* s, size_type pos, size_type n) const;
 139       constexpr size_type rfind(const charT* s, size_type pos = npos) const;
 140       constexpr size_type find_first_of(basic_string_view s, size_type pos = 0) const noexcept;
 141       constexpr size_type find_first_of(charT c, size_type pos = 0) const noexcept;
 142       constexpr size_type find_first_of(const charT* s, size_type pos, size_type n) const;
 143       constexpr size_type find_first_of(const charT* s, size_type pos = 0) const;
 144       constexpr size_type find_last_of(basic_string_view s, size_type pos = npos) const noexcept;
 145       constexpr size_type find_last_of(charT c, size_type pos = npos) const noexcept;
 146       constexpr size_type find_last_of(const charT* s, size_type pos, size_type n) const;
 147       constexpr size_type find_last_of(const charT* s, size_type pos = npos) const;
 148       constexpr size_type find_first_not_of(basic_string_view s, size_type pos = 0) const noexcept;
 149       constexpr size_type find_first_not_of(charT c, size_type pos = 0) const noexcept;
 150       constexpr size_type find_first_not_of(const charT* s, size_type pos, size_type n) const;
 151       constexpr size_type find_first_not_of(const charT* s, size_type pos = 0) const;
 152       constexpr size_type find_last_not_of(basic_string_view s, size_type pos = npos) const noexcept;
 153       constexpr size_type find_last_not_of(charT c, size_type pos = npos) const noexcept;
 154       constexpr size_type find_last_not_of(const charT* s, size_type pos, size_type n) const;
 155       constexpr size_type find_last_not_of(const charT* s, size_type pos = npos) const;
 156
 157      private:
 158       const_pointer data_;  // exposition only
 159       size_type     size_;  // exposition only
 160     };
 161
 162   }  // namespace fundamentals_v1
 163  }  // namespace experimental
 164
 165   // 7.11, Hash support
 166   template <class T> struct hash;
 167   template <> struct hash<experimental::string_view>;
 168   template <> struct hash<experimental::u16string_view>;
 169   template <> struct hash<experimental::u32string_view>;
 170   template <> struct hash<experimental::wstring_view>;
 171
 172 }  // namespace std
 173
 174
 175 */
 176
 177 #include <experimental/__config>
 178
 179 #include <string>
 180 #include <algorithm>
 181 #include <iterator>
 182 #include <ostream>
 183 #include <iomanip>
 184
 185 #include <__debug>
 186
 187 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 188 #pragma GCC system_header
 189 #endif
 190
 191 _LIBCPP_BEGIN_NAMESPACE_LFTS
 192
 193     template<class _CharT, class _Traits = _VSTD::char_traits<_CharT> >
 194     class _LIBCPP_TYPE_VIS_ONLY basic_string_view {
 195     public:
 196         // types
 197         typedef _Traits                                    traits_type;
 198         typedef _CharT                                     value_type;
 199         typedef const _CharT*                              pointer;
 200         typedef const _CharT*                              const_pointer;
 201         typedef const _CharT&                              reference;
 202         typedef const _CharT&                              const_reference;
 203         typedef const_pointer                              const_iterator; // See [string.view.iterators]
 204         typedef const_iterator                             iterator;
 205         typedef _VSTD::reverse_iterator<const_iterator>    const_reverse_iterator;
 206         typedef const_reverse_iterator                     reverse_iterator;
 207         typedef size_t                                     size_type;
 208         typedef ptrdiff_t                                  difference_type;
 209         static _LIBCPP_CONSTEXPR const size_type npos = -1; // size_type(-1);
 210
 211         // [string.view.cons], construct/copy
 212         _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
 213         basic_string_view() _NOEXCEPT : __data (nullptr), __size(0) {}
 214
 215         _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
 216         basic_string_view(const basic_string_view&) _NOEXCEPT = default;
 217
 218         _LIBCPP_INLINE_VISIBILITY
 219         basic_string_view& operator=(const basic_string_view&) _NOEXCEPT = default;
 220
 221         template<class _Allocator>
 222         _LIBCPP_INLINE_VISIBILITY
 223         basic_string_view(const basic_string<_CharT, _Traits, _Allocator>& __str) _NOEXCEPT
 224             : __data (__str.data()), __size(__str.size()) {}
 225
 226         _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
 227         basic_string_view(const _CharT* __s, size_type __len)
 228             : __data(__s), __size(__len)
 229         {
 230 //             _LIBCPP_ASSERT(__len == 0 || __s != nullptr, "string_view::string_view(_CharT *, size_t): recieved nullptr");
 231         }
 232
 233         _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
 234         basic_string_view(const _CharT* __s)
 235             : __data(__s), __size(_Traits::length(__s)) {}
 236
 237         // [string.view.iterators], iterators
 238         _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
 239         const_iterator begin()  const _NOEXCEPT { return cbegin(); }
 240
 241         _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
 242         const_iterator end()    const _NOEXCEPT { return cend(); }
 243
 244         _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
 245         const_iterator cbegin() const _NOEXCEPT { return __data; }
 246
 247         _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
 248         const_iterator cend()   const _NOEXCEPT { return __data + __size; }
 249
 250         _LIBCPP_INLINE_VISIBILITY
 251         const_reverse_iterator rbegin()   const _NOEXCEPT { return const_reverse_iterator(cend()); }
 252
 253         _LIBCPP_INLINE_VISIBILITY
 254         const_reverse_iterator rend()     const _NOEXCEPT { return const_reverse_iterator(cbegin()); }
 255
 256         _LIBCPP_INLINE_VISIBILITY
 257         const_reverse_iterator crbegin()  const _NOEXCEPT { return const_reverse_iterator(cend()); }
 258
 259         _LIBCPP_INLINE_VISIBILITY
 260         const_reverse_iterator crend()    const _NOEXCEPT { return const_reverse_iterator(cbegin()); }
 261
 262         // [string.view.capacity], capacity
 263         _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
 264         size_type size()     const _NOEXCEPT { return __size; }
 265
 266         _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
 267         size_type length()   const _NOEXCEPT { return __size; }
 268
 269         _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
 270         size_type max_size() const _NOEXCEPT { return _VSTD::numeric_limits<size_type>::max(); }
 271
 272         _LIBCPP_CONSTEXPR bool _LIBCPP_INLINE_VISIBILITY
 273         empty()         const _NOEXCEPT { return __size == 0; }
 274
 275         // [string.view.access], element access
 276         _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
 277         const_reference operator[](size_type __pos) const { return __data[__pos]; }
 278
 279         _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
 280         const_reference at(size_type __pos) const
 281         {
 282             return __pos >= size()
 283                 ? (throw out_of_range("string_view::at"), __data[0])
 284                 : __data[__pos];
 285         }
 286
 287         _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
 288         const_reference front() const
 289         {
 290             return _LIBCPP_ASSERT(!empty(), "string_view::front(): string is empty"), __data[0];
 291         }
 292
 293         _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
 294         const_reference back() const
 295         {
 296             return _LIBCPP_ASSERT(!empty(), "string_view::back(): string is empty"), __data[__size-1];
 297         }
 298
 299         _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
 300         const_pointer data() const _NOEXCEPT { return __data; }
 301
 302         // [string.view.modifiers], modifiers:
 303         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 304         void clear() _NOEXCEPT
 305         {
 306             __data = nullptr;
 307             __size = 0;
 308         }
 309
 310         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 311         void remove_prefix(size_type __n) _NOEXCEPT
 312         {
 313             _LIBCPP_ASSERT(__n <= size(), "remove_prefix() can't remove more than size()");
 314             __data += __n;
 315             __size -= __n;
 316         }
 317
 318         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 319         void remove_suffix(size_type __n) _NOEXCEPT
 320         {
 321             _LIBCPP_ASSERT(__n <= size(), "remove_suffix() can't remove more than size()");
 322             __size -= __n;
 323         }
 324
 325         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 326         void swap(basic_string_view& __other) _NOEXCEPT
 327         {
 328             const value_type *__p = __data;
 329             __data = __other.__data;
 330             __other.__data = __p;
 331
 332             size_type __sz = __size;
 333             __size = __other.__size;
 334             __other.__size = __sz;
 335 //             _VSTD::swap( __data, __other.__data );
 336 //             _VSTD::swap( __size, __other.__size );
 337         }
 338
 339         // [string.view.ops], string operations:
 340         template<class _Allocator>
 341         _LIBCPP_INLINE_VISIBILITY
 342         _LIBCPP_EXPLICIT operator basic_string<_CharT, _Traits, _Allocator>() const
 343         { return basic_string<_CharT, _Traits, _Allocator>( begin(), end()); }
 344
 345         template<class _Allocator = allocator<_CharT> >
 346         _LIBCPP_INLINE_VISIBILITY
 347         basic_string<_CharT, _Traits, _Allocator>
 348         to_string( const _Allocator& __a = _Allocator()) const
 349         { return basic_string<_CharT, _Traits, _Allocator> ( begin(), end(), __a ); }
 350
 351         size_type copy(_CharT* __s, size_type __n, size_type __pos = 0) const
 352         {
 353             if ( __pos > size())
 354                 throw out_of_range("string_view::copy");
 355             size_type __rlen = _VSTD::min( __n, size() - __pos );
 356             _VSTD::copy_n(begin() + __pos, __rlen, __s );
 357             return __rlen;
 358         }
 359
 360         _LIBCPP_CONSTEXPR
 361         basic_string_view substr(size_type __pos = 0, size_type __n = npos) const
 362         {
 363 //             if (__pos > size())
 364 //                 throw out_of_range("string_view::substr");
 365 //             size_type __rlen = _VSTD::min( __n, size() - __pos );
 366 //             return basic_string_view(data() + __pos, __rlen);
 367             return __pos > size()
 368                 ? throw out_of_range("string_view::substr")
 369                 : basic_string_view(data() + __pos, _VSTD::min(__n, size() - __pos));
 370         }
 371
 372         _LIBCPP_CONSTEXPR_AFTER_CXX11 int compare(basic_string_view __sv) const _NOEXCEPT
 373         {
 374             size_type __rlen = _VSTD::min( size(), __sv.size());
 375             int __retval = _Traits::compare(data(), __sv.data(), __rlen);
 376             if ( __retval == 0 ) // first __rlen chars matched
 377                 __retval = size() == __sv.size() ? 0 : ( size() < __sv.size() ? -1 : 1 );
 378             return __retval;
 379         }
 380
 381         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 382         int compare(size_type __pos1, size_type __n1, basic_string_view __sv) const
 383         {
 384             return substr(__pos1, __n1).compare(__sv);
 385         }
 386
 387         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 388         int compare(                       size_type __pos1, size_type __n1,
 389                     basic_string_view _sv, size_type __pos2, size_type __n2) const
 390         {
 391             return substr(__pos1, __n1).compare(_sv.substr(__pos2, __n2));
 392         }
 393
 394         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 395         int compare(const _CharT* __s) const
 396         {
 397             return compare(basic_string_view(__s));
 398         }
 399
 400         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 401         int compare(size_type __pos1, size_type __n1, const _CharT* __s) const
 402         {
 403             return substr(__pos1, __n1).compare(basic_string_view(__s));
 404         }
 405
 406         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 407         int compare(size_type __pos1, size_type __n1, const _CharT* __s, size_type __n2) const
 408         {
 409             return substr(__pos1, __n1).compare(basic_string_view(__s, __n2));
 410         }
 411
 412         // find
 413         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 414         size_type find(basic_string_view __s, size_type __pos = 0) const _NOEXCEPT
 415         {
 416             _LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find(): recieved nullptr");
 417             return _VSTD::__str_find<value_type, size_type, traits_type, npos>
 418                 (data(), size(), __s.data(), __pos, __s.size());
 419         }
 420
 421         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 422         size_type find(_CharT __c, size_type __pos = 0) const _NOEXCEPT
 423         {
 424             return _VSTD::__str_find<value_type, size_type, traits_type, npos>
 425                 (data(), size(), __c, __pos);
 426         }
 427
 428         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 429         size_type find(const _CharT* __s, size_type __pos, size_type __n) const
 430         {
 431             _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find(): recieved nullptr");
 432             return _VSTD::__str_find<value_type, size_type, traits_type, npos>
 433                 (data(), size(), __s, __pos, __n);
 434         }
 435
 436         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 437         size_type find(const _CharT* __s, size_type __pos = 0) const
 438         {
 439             _LIBCPP_ASSERT(__s != nullptr, "string_view::find(): recieved nullptr");
 440             return _VSTD::__str_find<value_type, size_type, traits_type, npos>
 441                 (data(), size(), __s, __pos, traits_type::length(__s));
 442         }
 443
 444         // rfind
 445         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 446         size_type rfind(basic_string_view __s, size_type __pos = npos) const _NOEXCEPT
 447         {
 448             _LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find(): recieved nullptr");
 449             return _VSTD::__str_rfind<value_type, size_type, traits_type, npos>
 450                 (data(), size(), __s.data(), __pos, __s.size());
 451         }
 452
 453         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 454         size_type rfind(_CharT __c, size_type __pos = npos) const _NOEXCEPT
 455         {
 456             return _VSTD::__str_rfind<value_type, size_type, traits_type, npos>
 457                 (data(), size(), __c, __pos);
 458         }
 459
 460         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 461         size_type rfind(const _CharT* __s, size_type __pos, size_type __n) const
 462         {
 463             _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::rfind(): recieved nullptr");
 464             return _VSTD::__str_rfind<value_type, size_type, traits_type, npos>
 465                 (data(), size(), __s, __pos, __n);
 466         }
 467
 468         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 469         size_type rfind(const _CharT* __s, size_type __pos=npos) const
 470         {
 471             _LIBCPP_ASSERT(__s != nullptr, "string_view::rfind(): recieved nullptr");
 472             return _VSTD::__str_rfind<value_type, size_type, traits_type, npos>
 473                 (data(), size(), __s, __pos, traits_type::length(__s));
 474         }
 475
 476         // find_first_of
 477         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 478         size_type find_first_of(basic_string_view __s, size_type __pos = 0) const _NOEXCEPT
 479         {
 480             _LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find_first_of(): recieved nullptr");
 481             return _VSTD::__str_find_first_of<value_type, size_type, traits_type, npos>
 482                 (data(), size(), __s.data(), __pos, __s.size());
 483         }
 484
 485         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 486         size_type find_first_of(_CharT __c, size_type __pos = 0) const _NOEXCEPT
 487         { return find(__c, __pos); }
 488
 489         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 490         size_type find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
 491         {
 492             _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find_first_of(): recieved nullptr");
 493             return _VSTD::__str_find_first_of<value_type, size_type, traits_type, npos>
 494                 (data(), size(), __s, __pos, __n);
 495         }
 496
 497         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 498         size_type find_first_of(const _CharT* __s, size_type __pos=0) const
 499         {
 500             _LIBCPP_ASSERT(__s != nullptr, "string_view::find_first_of(): recieved nullptr");
 501             return _VSTD::__str_find_first_of<value_type, size_type, traits_type, npos>
 502                 (data(), size(), __s, __pos, traits_type::length(__s));
 503         }
 504
 505         // find_last_of
 506         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 507         size_type find_last_of(basic_string_view __s, size_type __pos=npos) const _NOEXCEPT
 508         {
 509             _LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find_last_of(): recieved nullptr");
 510             return _VSTD::__str_find_last_of<value_type, size_type, traits_type, npos>
 511                 (data(), size(), __s.data(), __pos, __s.size());
 512         }
 513
 514         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 515         size_type find_last_of(_CharT __c, size_type __pos = npos) const _NOEXCEPT
 516         { return rfind(__c, __pos); }
 517
 518         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 519         size_type find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
 520         {
 521             _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find_last_of(): recieved nullptr");
 522             return _VSTD::__str_find_last_of<value_type, size_type, traits_type, npos>
 523                 (data(), size(), __s, __pos, __n);
 524         }
 525
 526         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 527         size_type find_last_of(const _CharT* __s, size_type __pos=npos) const
 528         {
 529             _LIBCPP_ASSERT(__s != nullptr, "string_view::find_last_of(): recieved nullptr");
 530             return _VSTD::__str_find_last_of<value_type, size_type, traits_type, npos>
 531                 (data(), size(), __s, __pos, traits_type::length(__s));
 532         }
 533
 534         // find_first_not_of
 535         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 536         size_type find_first_not_of(basic_string_view __s, size_type __pos=0) const _NOEXCEPT
 537         {
 538             _LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find_first_not_of(): recieved nullptr");
 539             return _VSTD::__str_find_first_not_of<value_type, size_type, traits_type, npos>
 540                 (data(), size(), __s.data(), __pos, __s.size());
 541         }
 542
 543         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 544         size_type find_first_not_of(_CharT __c, size_type __pos=0) const _NOEXCEPT
 545         {
 546             return _VSTD::__str_find_first_not_of<value_type, size_type, traits_type, npos>
 547                 (data(), size(), __c, __pos);
 548         }
 549
 550         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 551         size_type find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const
 552         {
 553             _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find_first_not_of(): recieved nullptr");
 554             return _VSTD::__str_find_first_not_of<value_type, size_type, traits_type, npos>
 555                 (data(), size(), __s, __pos, __n);
 556         }
 557
 558         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 559         size_type find_first_not_of(const _CharT* __s, size_type __pos=0) const
 560         {
 561             _LIBCPP_ASSERT(__s != nullptr, "string_view::find_first_not_of(): recieved nullptr");
 562             return _VSTD::__str_find_first_not_of<value_type, size_type, traits_type, npos>
 563                 (data(), size(), __s, __pos, traits_type::length(__s));
 564         }
 565
 566         // find_last_not_of
 567         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 568         size_type find_last_not_of(basic_string_view __s, size_type __pos=npos) const _NOEXCEPT
 569         {
 570             _LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find_last_not_of(): recieved nullptr");
 571             return _VSTD::__str_find_last_not_of<value_type, size_type, traits_type, npos>
 572                 (data(), size(), __s.data(), __pos, __s.size());
 573         }
 574
 575         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 576         size_type find_last_not_of(_CharT __c, size_type __pos=npos) const _NOEXCEPT
 577         {
 578             return _VSTD::__str_find_last_not_of<value_type, size_type, traits_type, npos>
 579                 (data(), size(), __c, __pos);
 580         }
 581
 582         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 583         size_type find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const
 584         {
 585             _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find_last_not_of(): recieved nullptr");
 586             return _VSTD::__str_find_last_not_of<value_type, size_type, traits_type, npos>
 587                 (data(), size(), __s, __pos, __n);
 588         }
 589
 590         _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 591         size_type find_last_not_of(const _CharT* __s, size_type __pos=npos) const
 592         {
 593             _LIBCPP_ASSERT(__s != nullptr, "string_view::find_last_not_of(): recieved nullptr");
 594             return _VSTD::__str_find_last_not_of<value_type, size_type, traits_type, npos>
 595                 (data(), size(), __s, __pos, traits_type::length(__s));
 596         }
 597
 598     private:
 599         const   value_type* __data;
 600         size_type           __size;
 601     };
 602
 603
 604     // [string.view.comparison]
 605     // operator ==
 606     template<class _CharT, class _Traits>
 607     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 608     bool operator==(basic_string_view<_CharT, _Traits> __lhs,
 609                     basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
 610     {
 611         if ( __lhs.size() != __rhs.size()) return false;
 612         return __lhs.compare(__rhs) == 0;
 613     }
 614
 615     template<class _CharT, class _Traits>
 616     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 617     bool operator==(basic_string_view<_CharT, _Traits> __lhs,
 618                     typename _VSTD::common_type<basic_string_view<_CharT, _Traits> >::type __rhs) _NOEXCEPT
 619     {
 620         if ( __lhs.size() != __rhs.size()) return false;
 621         return __lhs.compare(__rhs) == 0;
 622     }
 623
 624     template<class _CharT, class _Traits>
 625     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 626     bool operator==(typename _VSTD::common_type<basic_string_view<_CharT, _Traits> >::type __lhs,
 627                     basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
 628     {
 629         if ( __lhs.size() != __rhs.size()) return false;
 630         return __lhs.compare(__rhs) == 0;
 631     }
 632
 633
 634     // operator !=
 635     template<class _CharT, class _Traits>
 636     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 637     bool operator!=(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
 638     {
 639         if ( __lhs.size() != __rhs.size())
 640             return true;
 641         return __lhs.compare(__rhs) != 0;
 642     }
 643
 644     template<class _CharT, class _Traits>
 645     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 646     bool operator!=(basic_string_view<_CharT, _Traits> __lhs,
 647                     typename _VSTD::common_type<basic_string_view<_CharT, _Traits> >::type __rhs) _NOEXCEPT
 648     {
 649         if ( __lhs.size() != __rhs.size())
 650             return true;
 651         return __lhs.compare(__rhs) != 0;
 652     }
 653
 654     template<class _CharT, class _Traits>
 655     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 656     bool operator!=(typename _VSTD::common_type<basic_string_view<_CharT, _Traits> >::type __lhs,
 657                     basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
 658     {
 659         if ( __lhs.size() != __rhs.size())
 660             return true;
 661         return __lhs.compare(__rhs) != 0;
 662     }
 663
 664
 665     // operator <
 666     template<class _CharT, class _Traits>
 667     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 668     bool operator<(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
 669     {
 670         return __lhs.compare(__rhs) < 0;
 671     }
 672
 673     template<class _CharT, class _Traits>
 674     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 675     bool operator<(basic_string_view<_CharT, _Traits> __lhs,
 676                     typename _VSTD::common_type<basic_string_view<_CharT, _Traits> >::type __rhs) _NOEXCEPT
 677     {
 678         return __lhs.compare(__rhs) < 0;
 679     }
 680
 681     template<class _CharT, class _Traits>
 682     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 683     bool operator<(typename _VSTD::common_type<basic_string_view<_CharT, _Traits> >::type __lhs,
 684                     basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
 685     {
 686         return __lhs.compare(__rhs) < 0;
 687     }
 688
 689
 690     // operator >
 691     template<class _CharT, class _Traits>
 692     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 693     bool operator> (basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
 694     {
 695         return __lhs.compare(__rhs) > 0;
 696     }
 697
 698     template<class _CharT, class _Traits>
 699     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 700     bool operator>(basic_string_view<_CharT, _Traits> __lhs,
 701                     typename _VSTD::common_type<basic_string_view<_CharT, _Traits> >::type __rhs) _NOEXCEPT
 702     {
 703         return __lhs.compare(__rhs) > 0;
 704     }
 705
 706     template<class _CharT, class _Traits>
 707     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 708     bool operator>(typename _VSTD::common_type<basic_string_view<_CharT, _Traits> >::type __lhs,
 709                     basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
 710     {
 711         return __lhs.compare(__rhs) > 0;
 712     }
 713
 714
 715     // operator <=
 716     template<class _CharT, class _Traits>
 717     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 718     bool operator<=(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
 719     {
 720         return __lhs.compare(__rhs) <= 0;
 721     }
 722
 723     template<class _CharT, class _Traits>
 724     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 725     bool operator<=(basic_string_view<_CharT, _Traits> __lhs,
 726                     typename _VSTD::common_type<basic_string_view<_CharT, _Traits> >::type __rhs) _NOEXCEPT
 727     {
 728         return __lhs.compare(__rhs) <= 0;
 729     }
 730
 731     template<class _CharT, class _Traits>
 732     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 733     bool operator<=(typename _VSTD::common_type<basic_string_view<_CharT, _Traits> >::type __lhs,
 734                     basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
 735     {
 736         return __lhs.compare(__rhs) <= 0;
 737     }
 738
 739
 740     // operator >=
 741     template<class _CharT, class _Traits>
 742     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 743     bool operator>=(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
 744     {
 745         return __lhs.compare(__rhs) >= 0;
 746     }
 747
 748
 749     template<class _CharT, class _Traits>
 750     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 751     bool operator>=(basic_string_view<_CharT, _Traits> __lhs,
 752                     typename _VSTD::common_type<basic_string_view<_CharT, _Traits> >::type __rhs) _NOEXCEPT
 753     {
 754         return __lhs.compare(__rhs) >= 0;
 755     }
 756
 757     template<class _CharT, class _Traits>
 758     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 759     bool operator>=(typename _VSTD::common_type<basic_string_view<_CharT, _Traits> >::type __lhs,
 760                     basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
 761     {
 762         return __lhs.compare(__rhs) >= 0;
 763     }
 764
 765
 766     // [string.view.io]
 767     template<class _CharT, class _Traits>
 768     basic_ostream<_CharT, _Traits>&
 769     operator<<(basic_ostream<_CharT, _Traits>& __os, basic_string_view<_CharT, _Traits> __sv)
 770     {
 771         return _VSTD::__put_character_sequence(__os, __sv.data(), __sv.size());
 772     }
 773
 774   typedef basic_string_view<char>     string_view;
 775   typedef basic_string_view<char16_t> u16string_view;
 776   typedef basic_string_view<char32_t> u32string_view;
 777   typedef basic_string_view<wchar_t>  wstring_view;
 778
 779 _LIBCPP_END_NAMESPACE_LFTS
 780 _LIBCPP_BEGIN_NAMESPACE_STD
 781
 782 // [string.view.hash]
 783 // Shamelessly stolen from <string>
 784 template<class _CharT, class _Traits>
 785 struct _LIBCPP_TYPE_VIS_ONLY hash<std::experimental::basic_string_view<_CharT, _Traits> >
 786     : public unary_function<std::experimental::basic_string_view<_CharT, _Traits>, size_t>
 787 {
 788     size_t operator()(const std::experimental::basic_string_view<_CharT, _Traits>& __val) const _NOEXCEPT;
 789 };
 790
 791 template<class _CharT, class _Traits>
 792 size_t
 793 hash<std::experimental::basic_string_view<_CharT, _Traits> >::operator()(
 794         const std::experimental::basic_string_view<_CharT, _Traits>& __val) const _NOEXCEPT
 795 {
 796     return __do_string_hash(__val.data(), __val.data() + __val.size());
 797 }
 798
 799 #if _LIBCPP_STD_VER > 11
 800 template <class _CharT, class _Traits>
 801 __quoted_output_proxy<_CharT, const _CharT *, _Traits>
 802 quoted ( std::experimental::basic_string_view <_CharT, _Traits> __sv,
 803              _CharT __delim = _CharT('"'), _CharT __escape=_CharT('\\'))
 804 {
 805     return __quoted_output_proxy<_CharT, const _CharT *, _Traits>
 806          ( __sv.data(), __sv.data() + __sv.size(), __delim, __escape );
 807 }
 808 #endif
 809
 810 _LIBCPP_END_NAMESPACE_STD
 811
 812 #endif // _LIBCPP_LFTS_STRING_VIEW