1// Components for manipulating non-owning sequences of characters -*- C++ -*- 2 3// Copyright (C) 2013-2018 Free Software Foundation, Inc. 4// 5// This file is part of the GNU ISO C++ Library. This library is free 6// software; you can redistribute it and/or modify it under the 7// terms of the GNU General Public License as published by the 8// Free Software Foundation; either version 3, or (at your option) 9// any later version. 10 11// This library is distributed in the hope that it will be useful, 12// but WITHOUT ANY WARRANTY; without even the implied warranty of 13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14// GNU General Public License for more details. 15 16// Under Section 7 of GPL version 3, you are granted additional 17// permissions described in the GCC Runtime Library Exception, version 18// 3.1, as published by the Free Software Foundation. 19 20// You should have received a copy of the GNU General Public License and 21// a copy of the GCC Runtime Library Exception along with this program; 22// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 23// <http://www.gnu.org/licenses/>. 24 25/** @file experimental/string_view 26 * This is a TS C++ Library header. 27 */ 28 29// 30// N3762 basic_string_view library 31// 32 33#ifndef _GLIBCXX_EXPERIMENTAL_STRING_VIEW 34#define _GLIBCXX_EXPERIMENTAL_STRING_VIEW 1 35 36#pragma GCC system_header 37 38#if __cplusplus >= 201402L 39 40#include <string> 41#include <limits> 42#include <experimental/bits/lfts_config.h> 43 44namespace std _GLIBCXX_VISIBILITY(default) 45{ 46_GLIBCXX_BEGIN_NAMESPACE_VERSION 47 48namespace experimental 49{ 50inline namespace fundamentals_v1 51{ 52#define __cpp_lib_experimental_string_view 201411 53 54 /** 55 * @class basic_string_view <experimental/string_view> 56 * @brief A non-owning reference to a string. 57 * 58 * @ingroup strings 59 * @ingroup sequences 60 * @ingroup experimental 61 * 62 * @tparam _CharT Type of character 63 * @tparam _Traits Traits for character type, defaults to 64 * char_traits<_CharT>. 65 * 66 * A basic_string_view looks like this: 67 * 68 * @code 69 * _CharT* _M_str 70 * size_t _M_len 71 * @endcode 72 */ 73 template<typename _CharT, typename _Traits = std::char_traits<_CharT>> 74 class basic_string_view 75 { 76 public: 77 78 // types 79 using traits_type = _Traits; 80 using value_type = _CharT; 81 using pointer = const _CharT*; 82 using const_pointer = const _CharT*; 83 using reference = const _CharT&; 84 using const_reference = const _CharT&; 85 using const_iterator = const _CharT*; 86 using iterator = const_iterator; 87 using const_reverse_iterator = std::reverse_iterator<const_iterator>; 88 using reverse_iterator = const_reverse_iterator; 89 using size_type = size_t; 90 using difference_type = ptrdiff_t; 91 static constexpr size_type npos = size_type(-1); 92 93 // [string.view.cons], construct/copy 94 95 constexpr 96 basic_string_view() noexcept 97 : _M_len{0}, _M_str{nullptr} 98 { } 99 100 constexpr basic_string_view(const basic_string_view&) noexcept = default; 101 102 template<typename _Allocator> 103 basic_string_view(const basic_string<_CharT, _Traits, 104 _Allocator>& __str) noexcept 105 : _M_len{__str.length()}, _M_str{__str.data()} 106 { } 107 108 constexpr basic_string_view(const _CharT* __str) 109 : _M_len{__str == nullptr ? 0 : traits_type::length(__str)}, 110 _M_str{__str} 111 { } 112 113 constexpr basic_string_view(const _CharT* __str, size_type __len) 114 : _M_len{__len}, 115 _M_str{__str} 116 { } 117 118 basic_string_view& 119 operator=(const basic_string_view&) noexcept = default; 120 121 // [string.view.iterators], iterators 122 123 constexpr const_iterator 124 begin() const noexcept 125 { return this->_M_str; } 126 127 constexpr const_iterator 128 end() const noexcept 129 { return this->_M_str + this->_M_len; } 130 131 constexpr const_iterator 132 cbegin() const noexcept 133 { return this->_M_str; } 134 135 constexpr const_iterator 136 cend() const noexcept 137 { return this->_M_str + this->_M_len; } 138 139 const_reverse_iterator 140 rbegin() const noexcept 141 { return const_reverse_iterator(this->end()); } 142 143 const_reverse_iterator 144 rend() const noexcept 145 { return const_reverse_iterator(this->begin()); } 146 147 const_reverse_iterator 148 crbegin() const noexcept 149 { return const_reverse_iterator(this->end()); } 150 151 const_reverse_iterator 152 crend() const noexcept 153 { return const_reverse_iterator(this->begin()); } 154 155 // [string.view.capacity], capacity 156 157 constexpr size_type 158 size() const noexcept 159 { return this->_M_len; } 160 161 constexpr size_type 162 length() const noexcept 163 { return _M_len; } 164 165 constexpr size_type 166 max_size() const noexcept 167 { 168 return (npos - sizeof(size_type) - sizeof(void*)) 169 / sizeof(value_type) / 4; 170 } 171 172 constexpr bool 173 empty() const noexcept 174 { return this->_M_len == 0; } 175 176 // [string.view.access], element access 177 178 constexpr const _CharT& 179 operator[](size_type __pos) const 180 { 181 // TODO: Assert to restore in a way compatible with the constexpr. 182 // __glibcxx_assert(__pos < this->_M_len); 183 return *(this->_M_str + __pos); 184 } 185 186 constexpr const _CharT& 187 at(size_type __pos) const 188 { 189 return __pos < this->_M_len 190 ? *(this->_M_str + __pos) 191 : (__throw_out_of_range_fmt(__N("basic_string_view::at: __pos " 192 "(which is %zu) >= this->size() " 193 "(which is %zu)"), 194 __pos, this->size()), 195 *this->_M_str); 196 } 197 198 constexpr const _CharT& 199 front() const 200 { 201 // TODO: Assert to restore in a way compatible with the constexpr. 202 // __glibcxx_assert(this->_M_len > 0); 203 return *this->_M_str; 204 } 205 206 constexpr const _CharT& 207 back() const 208 { 209 // TODO: Assert to restore in a way compatible with the constexpr. 210 // __glibcxx_assert(this->_M_len > 0); 211 return *(this->_M_str + this->_M_len - 1); 212 } 213 214 constexpr const _CharT* 215 data() const noexcept 216 { return this->_M_str; } 217 218 // [string.view.modifiers], modifiers: 219 220 constexpr void 221 remove_prefix(size_type __n) 222 { 223 __glibcxx_assert(this->_M_len >= __n); 224 this->_M_str += __n; 225 this->_M_len -= __n; 226 } 227 228 constexpr void 229 remove_suffix(size_type __n) 230 { this->_M_len -= __n; } 231 232 constexpr void 233 swap(basic_string_view& __sv) noexcept 234 { 235 auto __tmp = *this; 236 *this = __sv; 237 __sv = __tmp; 238 } 239 240 241 // [string.view.ops], string operations: 242 243 template<typename _Allocator> 244 explicit operator basic_string<_CharT, _Traits, _Allocator>() const 245 { 246 return { this->_M_str, this->_M_len }; 247 } 248 249 template<typename _Allocator = std::allocator<_CharT>> 250 basic_string<_CharT, _Traits, _Allocator> 251 to_string(const _Allocator& __alloc = _Allocator()) const 252 { 253 return { this->_M_str, this->_M_len, __alloc }; 254 } 255 256 size_type 257 copy(_CharT* __str, size_type __n, size_type __pos = 0) const 258 { 259 __glibcxx_requires_string_len(__str, __n); 260 if (__pos > this->_M_len) 261 __throw_out_of_range_fmt(__N("basic_string_view::copy: __pos " 262 "(which is %zu) > this->size() " 263 "(which is %zu)"), 264 __pos, this->size()); 265 size_type __rlen{std::min(__n, size_type{this->_M_len - __pos})}; 266 for (auto __begin = this->_M_str + __pos, 267 __end = __begin + __rlen; __begin != __end;) 268 *__str++ = *__begin++; 269 return __rlen; 270 } 271 272 273 // [string.view.ops], string operations: 274 275 constexpr basic_string_view 276 substr(size_type __pos = 0, size_type __n = npos) const 277 { 278 return __pos <= this->_M_len 279 ? basic_string_view{this->_M_str + __pos, 280 std::min(__n, size_type{this->_M_len - __pos})} 281 : (__throw_out_of_range_fmt(__N("basic_string_view::substr: __pos " 282 "(which is %zu) > this->size() " 283 "(which is %zu)"), 284 __pos, this->size()), basic_string_view{}); 285 } 286 287 constexpr int 288 compare(basic_string_view __str) const noexcept 289 { 290 int __ret = traits_type::compare(this->_M_str, __str._M_str, 291 std::min(this->_M_len, __str._M_len)); 292 if (__ret == 0) 293 __ret = _S_compare(this->_M_len, __str._M_len); 294 return __ret; 295 } 296 297 constexpr int 298 compare(size_type __pos1, size_type __n1, basic_string_view __str) const 299 { return this->substr(__pos1, __n1).compare(__str); } 300 301 constexpr int 302 compare(size_type __pos1, size_type __n1, 303 basic_string_view __str, size_type __pos2, size_type __n2) const 304 { return this->substr(__pos1, __n1).compare(__str.substr(__pos2, __n2)); } 305 306 constexpr int 307 compare(const _CharT* __str) const noexcept 308 { return this->compare(basic_string_view{__str}); } 309 310 constexpr int 311 compare(size_type __pos1, size_type __n1, const _CharT* __str) const 312 { return this->substr(__pos1, __n1).compare(basic_string_view{__str}); } 313 314 constexpr int 315 compare(size_type __pos1, size_type __n1, 316 const _CharT* __str, size_type __n2) const 317 { 318 return this->substr(__pos1, __n1) 319 .compare(basic_string_view(__str, __n2)); 320 } 321 322 constexpr size_type 323 find(basic_string_view __str, size_type __pos = 0) const noexcept 324 { return this->find(__str._M_str, __pos, __str._M_len); } 325 326 constexpr size_type 327 find(_CharT __c, size_type __pos=0) const noexcept; 328 329 constexpr size_type 330 find(const _CharT* __str, size_type __pos, size_type __n) const noexcept; 331 332 constexpr size_type 333 find(const _CharT* __str, size_type __pos=0) const noexcept 334 { return this->find(__str, __pos, traits_type::length(__str)); } 335 336 constexpr size_type 337 rfind(basic_string_view __str, size_type __pos = npos) const noexcept 338 { return this->rfind(__str._M_str, __pos, __str._M_len); } 339 340 constexpr size_type 341 rfind(_CharT __c, size_type __pos = npos) const noexcept; 342 343 constexpr size_type 344 rfind(const _CharT* __str, size_type __pos, size_type __n) const noexcept; 345 346 constexpr size_type 347 rfind(const _CharT* __str, size_type __pos = npos) const noexcept 348 { return this->rfind(__str, __pos, traits_type::length(__str)); } 349 350 constexpr size_type 351 find_first_of(basic_string_view __str, size_type __pos = 0) const noexcept 352 { return this->find_first_of(__str._M_str, __pos, __str._M_len); } 353 354 constexpr size_type 355 find_first_of(_CharT __c, size_type __pos = 0) const noexcept 356 { return this->find(__c, __pos); } 357 358 constexpr size_type 359 find_first_of(const _CharT* __str, size_type __pos, size_type __n) const; 360 361 constexpr size_type 362 find_first_of(const _CharT* __str, size_type __pos = 0) const noexcept 363 { return this->find_first_of(__str, __pos, traits_type::length(__str)); } 364 365 constexpr size_type 366 find_last_of(basic_string_view __str, 367 size_type __pos = npos) const noexcept 368 { return this->find_last_of(__str._M_str, __pos, __str._M_len); } 369 370 constexpr size_type 371 find_last_of(_CharT __c, size_type __pos=npos) const noexcept 372 { return this->rfind(__c, __pos); } 373 374 constexpr size_type 375 find_last_of(const _CharT* __str, size_type __pos, size_type __n) const; 376 377 constexpr size_type 378 find_last_of(const _CharT* __str, size_type __pos = npos) const noexcept 379 { return this->find_last_of(__str, __pos, traits_type::length(__str)); } 380 381 constexpr size_type 382 find_first_not_of(basic_string_view __str, 383 size_type __pos = 0) const noexcept 384 { return this->find_first_not_of(__str._M_str, __pos, __str._M_len); } 385 386 constexpr size_type 387 find_first_not_of(_CharT __c, size_type __pos = 0) const noexcept; 388 389 constexpr size_type 390 find_first_not_of(const _CharT* __str, 391 size_type __pos, size_type __n) const; 392 393 constexpr size_type 394 find_first_not_of(const _CharT* __str, size_type __pos = 0) const noexcept 395 { 396 return this->find_first_not_of(__str, __pos, 397 traits_type::length(__str)); 398 } 399 400 constexpr size_type 401 find_last_not_of(basic_string_view __str, 402 size_type __pos = npos) const noexcept 403 { return this->find_last_not_of(__str._M_str, __pos, __str._M_len); } 404 405 constexpr size_type 406 find_last_not_of(_CharT __c, size_type __pos = npos) const noexcept; 407 408 constexpr size_type 409 find_last_not_of(const _CharT* __str, 410 size_type __pos, size_type __n) const; 411 412 constexpr size_type 413 find_last_not_of(const _CharT* __str, 414 size_type __pos = npos) const noexcept 415 { 416 return this->find_last_not_of(__str, __pos, 417 traits_type::length(__str)); 418 } 419 420 private: 421 422 static constexpr int 423 _S_compare(size_type __n1, size_type __n2) noexcept 424 { 425 return difference_type(__n1 - __n2) > std::numeric_limits<int>::max() 426 ? std::numeric_limits<int>::max() 427 : difference_type(__n1 - __n2) < std::numeric_limits<int>::min() 428 ? std::numeric_limits<int>::min() 429 : static_cast<int>(difference_type(__n1 - __n2)); 430 } 431 432 size_t _M_len; 433 const _CharT* _M_str; 434 }; 435 436 // [string.view.comparison], non-member basic_string_view comparison functions 437 438 namespace __detail 439 { 440 // Identity transform to create a non-deduced context, so that only one 441 // argument participates in template argument deduction and the other 442 // argument gets implicitly converted to the deduced type. See n3766.html. 443 template<typename _Tp> 444 using __idt = common_type_t<_Tp>; 445 } 446 447 template<typename _CharT, typename _Traits> 448 constexpr bool 449 operator==(basic_string_view<_CharT, _Traits> __x, 450 basic_string_view<_CharT, _Traits> __y) noexcept 451 { return __x.size() == __y.size() && __x.compare(__y) == 0; } 452 453 template<typename _CharT, typename _Traits> 454 constexpr bool 455 operator==(basic_string_view<_CharT, _Traits> __x, 456 __detail::__idt<basic_string_view<_CharT, _Traits>> __y) noexcept 457 { return __x.size() == __y.size() && __x.compare(__y) == 0; } 458 459 template<typename _CharT, typename _Traits> 460 constexpr bool 461 operator==(__detail::__idt<basic_string_view<_CharT, _Traits>> __x, 462 basic_string_view<_CharT, _Traits> __y) noexcept 463 { return __x.size() == __y.size() && __x.compare(__y) == 0; } 464 465 template<typename _CharT, typename _Traits> 466 constexpr bool 467 operator!=(basic_string_view<_CharT, _Traits> __x, 468 basic_string_view<_CharT, _Traits> __y) noexcept 469 { return !(__x == __y); } 470 471 template<typename _CharT, typename _Traits> 472 constexpr bool 473 operator!=(basic_string_view<_CharT, _Traits> __x, 474 __detail::__idt<basic_string_view<_CharT, _Traits>> __y) noexcept 475 { return !(__x == __y); } 476 477 template<typename _CharT, typename _Traits> 478 constexpr bool 479 operator!=(__detail::__idt<basic_string_view<_CharT, _Traits>> __x, 480 basic_string_view<_CharT, _Traits> __y) noexcept 481 { return !(__x == __y); } 482 483 template<typename _CharT, typename _Traits> 484 constexpr bool 485 operator< (basic_string_view<_CharT, _Traits> __x, 486 basic_string_view<_CharT, _Traits> __y) noexcept 487 { return __x.compare(__y) < 0; } 488 489 template<typename _CharT, typename _Traits> 490 constexpr bool 491 operator< (basic_string_view<_CharT, _Traits> __x, 492 __detail::__idt<basic_string_view<_CharT, _Traits>> __y) noexcept 493 { return __x.compare(__y) < 0; } 494 495 template<typename _CharT, typename _Traits> 496 constexpr bool 497 operator< (__detail::__idt<basic_string_view<_CharT, _Traits>> __x, 498 basic_string_view<_CharT, _Traits> __y) noexcept 499 { return __x.compare(__y) < 0; } 500 501 template<typename _CharT, typename _Traits> 502 constexpr bool 503 operator> (basic_string_view<_CharT, _Traits> __x, 504 basic_string_view<_CharT, _Traits> __y) noexcept 505 { return __x.compare(__y) > 0; } 506 507 template<typename _CharT, typename _Traits> 508 constexpr bool 509 operator> (basic_string_view<_CharT, _Traits> __x, 510 __detail::__idt<basic_string_view<_CharT, _Traits>> __y) noexcept 511 { return __x.compare(__y) > 0; } 512 513 template<typename _CharT, typename _Traits> 514 constexpr bool 515 operator> (__detail::__idt<basic_string_view<_CharT, _Traits>> __x, 516 basic_string_view<_CharT, _Traits> __y) noexcept 517 { return __x.compare(__y) > 0; } 518 519 template<typename _CharT, typename _Traits> 520 constexpr bool 521 operator<=(basic_string_view<_CharT, _Traits> __x, 522 basic_string_view<_CharT, _Traits> __y) noexcept 523 { return __x.compare(__y) <= 0; } 524 525 template<typename _CharT, typename _Traits> 526 constexpr bool 527 operator<=(basic_string_view<_CharT, _Traits> __x, 528 __detail::__idt<basic_string_view<_CharT, _Traits>> __y) noexcept 529 { return __x.compare(__y) <= 0; } 530 531 template<typename _CharT, typename _Traits> 532 constexpr bool 533 operator<=(__detail::__idt<basic_string_view<_CharT, _Traits>> __x, 534 basic_string_view<_CharT, _Traits> __y) noexcept 535 { return __x.compare(__y) <= 0; } 536 537 template<typename _CharT, typename _Traits> 538 constexpr bool 539 operator>=(basic_string_view<_CharT, _Traits> __x, 540 basic_string_view<_CharT, _Traits> __y) noexcept 541 { return __x.compare(__y) >= 0; } 542 543 template<typename _CharT, typename _Traits> 544 constexpr bool 545 operator>=(basic_string_view<_CharT, _Traits> __x, 546 __detail::__idt<basic_string_view<_CharT, _Traits>> __y) noexcept 547 { return __x.compare(__y) >= 0; } 548 549 template<typename _CharT, typename _Traits> 550 constexpr bool 551 operator>=(__detail::__idt<basic_string_view<_CharT, _Traits>> __x, 552 basic_string_view<_CharT, _Traits> __y) noexcept 553 { return __x.compare(__y) >= 0; } 554 555 // [string.view.io], Inserters and extractors 556 template<typename _CharT, typename _Traits> 557 inline basic_ostream<_CharT, _Traits>& 558 operator<<(basic_ostream<_CharT, _Traits>& __os, 559 basic_string_view<_CharT,_Traits> __str) 560 { return __ostream_insert(__os, __str.data(), __str.size()); } 561 562 563 // basic_string_view typedef names 564 565 using string_view = basic_string_view<char>; 566#ifdef _GLIBCXX_USE_WCHAR_T 567 using wstring_view = basic_string_view<wchar_t>; 568#endif 569#ifdef _GLIBCXX_USE_C99_STDINT_TR1 570 using u16string_view = basic_string_view<char16_t>; 571 using u32string_view = basic_string_view<char32_t>; 572#endif 573} // namespace fundamentals_v1 574} // namespace experimental 575 576 577 // [string.view.hash], hash support: 578 template<typename _Tp> 579 struct hash; 580 581 template<> 582 struct hash<experimental::string_view> 583 : public __hash_base<size_t, experimental::string_view> 584 { 585 size_t 586 operator()(const experimental::string_view& __str) const noexcept 587 { return std::_Hash_impl::hash(__str.data(), __str.length()); } 588 }; 589 590 template<> 591 struct __is_fast_hash<hash<experimental::string_view>> : std::false_type 592 { }; 593 594#ifdef _GLIBCXX_USE_WCHAR_T 595 template<> 596 struct hash<experimental::wstring_view> 597 : public __hash_base<size_t, wstring> 598 { 599 size_t 600 operator()(const experimental::wstring_view& __s) const noexcept 601 { return std::_Hash_impl::hash(__s.data(), 602 __s.length() * sizeof(wchar_t)); } 603 }; 604 605 template<> 606 struct __is_fast_hash<hash<experimental::wstring_view>> : std::false_type 607 { }; 608#endif 609 610#ifdef _GLIBCXX_USE_C99_STDINT_TR1 611 template<> 612 struct hash<experimental::u16string_view> 613 : public __hash_base<size_t, experimental::u16string_view> 614 { 615 size_t 616 operator()(const experimental::u16string_view& __s) const noexcept 617 { return std::_Hash_impl::hash(__s.data(), 618 __s.length() * sizeof(char16_t)); } 619 }; 620 621 template<> 622 struct __is_fast_hash<hash<experimental::u16string_view>> : std::false_type 623 { }; 624 625 template<> 626 struct hash<experimental::u32string_view> 627 : public __hash_base<size_t, experimental::u32string_view> 628 { 629 size_t 630 operator()(const experimental::u32string_view& __s) const noexcept 631 { return std::_Hash_impl::hash(__s.data(), 632 __s.length() * sizeof(char32_t)); } 633 }; 634 635 template<> 636 struct __is_fast_hash<hash<experimental::u32string_view>> : std::false_type 637 { }; 638#endif 639 640namespace experimental 641{ 642 // I added these EMSR. 643 inline namespace literals 644 { 645 inline namespace string_view_literals 646 { 647#pragma GCC diagnostic push 648#pragma GCC diagnostic ignored "-Wliteral-suffix" 649 inline constexpr basic_string_view<char> 650 operator""sv(const char* __str, size_t __len) noexcept 651 { return basic_string_view<char>{__str, __len}; } 652 653#ifdef _GLIBCXX_USE_WCHAR_T 654 inline constexpr basic_string_view<wchar_t> 655 operator""sv(const wchar_t* __str, size_t __len) noexcept 656 { return basic_string_view<wchar_t>{__str, __len}; } 657#endif 658 659#ifdef _GLIBCXX_USE_C99_STDINT_TR1 660 inline constexpr basic_string_view<char16_t> 661 operator""sv(const char16_t* __str, size_t __len) noexcept 662 { return basic_string_view<char16_t>{__str, __len}; } 663 664 inline constexpr basic_string_view<char32_t> 665 operator""sv(const char32_t* __str, size_t __len) noexcept 666 { return basic_string_view<char32_t>{__str, __len}; } 667#endif 668#pragma GCC diagnostic pop 669 } // namespace string_literals 670 } // namespace literals 671} // namespace experimental 672 673_GLIBCXX_END_NAMESPACE_VERSION 674} // namespace std 675 676#include <experimental/bits/string_view.tcc> 677 678#endif // __cplusplus <= 201103L 679 680#endif // _GLIBCXX_EXPERIMENTAL_STRING_VIEW 681