00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00052 #ifndef STLSOFT_INCL_STLSOFT_STRING_HPP_STRING_VIEW
00053 #define STLSOFT_INCL_STLSOFT_STRING_HPP_STRING_VIEW
00054
00055 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00056 # define STLSOFT_VER_STLSOFT_STRING_HPP_STRING_VIEW_MAJOR 3
00057 # define STLSOFT_VER_STLSOFT_STRING_HPP_STRING_VIEW_MINOR 3
00058 # define STLSOFT_VER_STLSOFT_STRING_HPP_STRING_VIEW_REVISION 1
00059 # define STLSOFT_VER_STLSOFT_STRING_HPP_STRING_VIEW_EDIT 92
00060 #endif
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077 #ifndef STLSOFT_INCL_STLSOFT_H_STLSOFT
00078 # include <stlsoft/stlsoft.h>
00079 #endif
00080 #if defined(STLSOFT_COMPILER_IS_MWERKS) && \
00081 ((__MWERKS__ & 0xff00) < 0x3000)
00082 # error stlsoft/string/string_view.hpp not compatible with Metrowerks 7.x (v2.4)
00083 #endif
00084 #ifndef STLSOFT_INCL_STLSOFT_STRING_HPP_CHAR_TRAITS
00085 # include <stlsoft/string/char_traits.hpp>
00086 #endif
00087 #ifndef STLSOFT_INCL_STLSOFT_STRING_HPP_STRING_TRAITS_FWD
00088 # include <stlsoft/string/string_traits_fwd.hpp>
00089 #endif
00090 #ifndef STLSOFT_INCL_STLSOFT_UTIL_STD_HPP_ITERATOR_HELPER
00091 # include <stlsoft/util/std/iterator_helper.hpp>
00092 #endif
00093 #ifndef STLSOFT_INCL_STLSOFT_COLLECTIONS_UTIL_HPP_COLLECTIONS
00094 # include <stlsoft/collections/util/collections.hpp>
00095 #endif
00096 #ifndef STLSOFT_INCL_STLSOFT_MEMORY_HPP_ALLOCATOR_SELECTOR
00097 # include <stlsoft/memory/allocator_selector.hpp>
00098 #endif
00099 #ifndef STLSOFT_INCL_STLSOFT_UTIL_HPP_STD_SWAP
00100 # include <stlsoft/util/std_swap.hpp>
00101 #endif
00102 #ifdef STLSOFT_CF_EXCEPTION_SUPPORT
00103 # include <stdexcept>
00104 #endif
00105
00106
00107
00108
00109
00110 #ifndef _STLSOFT_NO_NAMESPACE
00111 namespace stlsoft
00112 {
00113 #endif
00114
00115
00116
00117
00118
00119
00131 template< ss_typename_param_k C
00132 #ifdef STLSOFT_CF_TEMPLATE_CLASS_DEFAULT_CLASS_ARGUMENT_SUPPORT
00133 , ss_typename_param_k T = char_traits<C>
00134 , ss_typename_param_k A = ss_typename_type_def_k allocator_selector<C>::allocator_type
00135 #else
00136 , ss_typename_param_k T
00137 , ss_typename_param_k A
00138 #endif
00139 >
00140 class basic_string_view
00141 #if defined(STLSOFT_COMPILER_IS_DMC)
00142 : protected A
00143 #else
00144 : private A
00145 #endif
00146 , public stl_collection_tag
00147 {
00148 public:
00150 typedef C value_type;
00152 typedef T traits_type;
00154 typedef A allocator_type;
00156 typedef basic_string_view<C, T, A> class_type;
00158 typedef value_type char_type;
00159 #if 0
00164 typedef value_type const* pointer;
00165 #endif
00167 typedef value_type const* const_pointer;
00168 #if 0
00170 typedef value_type& reference;
00171 #endif
00173 typedef value_type const& const_reference;
00175 typedef ss_size_t size_type;
00177 typedef ss_ptrdiff_t difference_type;
00178
00179 #if 0
00181 typedef
00182 #if !defined(STLSOFT_COMPILER_IS_BORLAND)
00183 ss_typename_type_k
00184 #endif
00185 pointer_iterator < value_type
00186 , pointer
00187 , reference
00188 >::type iterator;
00189 #endif
00191 typedef
00192 #if !defined(STLSOFT_COMPILER_IS_BORLAND)
00193 ss_typename_type_k
00194 #endif
00195 pointer_iterator < value_type const
00196 , const_pointer
00197 , const_reference
00198 >::type const_iterator;
00199
00200 #if defined(STLSOFT_LF_BIDIRECTIONAL_ITERATOR_SUPPORT)
00201 #if 0
00203 typedef reverse_iterator_base < iterator
00204 , value_type
00205 , reference
00206 , pointer
00207 , difference_type
00208 > reverse_iterator;
00209 #endif
00210
00212 typedef const_reverse_iterator_base < const_iterator
00213 , value_type const
00214 , const_reference
00215 , const_pointer
00216 , difference_type
00217 > const_reverse_iterator;
00218 #endif
00219
00222 public:
00224 basic_string_view();
00226 basic_string_view(class_type const& rhs);
00228 basic_string_view(class_type const& s, size_type pos);
00230 basic_string_view(class_type const& s, size_type pos, size_type cch);
00232 basic_string_view(char_type const* s);
00234 basic_string_view(char_type const* s, size_type cch);
00236 basic_string_view(char_type const* first, char_type const* last);
00238 ~basic_string_view() stlsoft_throw_0();
00239
00241 class_type& operator =(class_type const& rhs);
00242
00244
00247 public:
00249 void swap(class_type& other) stlsoft_throw_0();
00250
00252 void clear() stlsoft_throw_0();
00253
00259 void refresh() stlsoft_throw_0();
00261
00264 public:
00266 size_type size() const stlsoft_throw_0();
00268 static size_type max_size() stlsoft_throw_0();
00270 size_type length() const stlsoft_throw_0();
00272 size_type capacity() const stlsoft_throw_0();
00274 ss_bool_t empty() const stlsoft_throw_0();
00275
00277 allocator_type get_allocator() const;
00279
00282 public:
00284 ss_bool_t equal(class_type const& rhs) const stlsoft_throw_0();
00286 ss_bool_t equal(value_type const* rhs, size_type cchRhs) const stlsoft_throw_0();
00287
00289 ss_sint_t compare(size_type pos, size_type cch, value_type const* s, size_type cchRhs) const stlsoft_throw_0();
00291 ss_sint_t compare(size_type pos, size_type cch, value_type const* s) const stlsoft_throw_0();
00293 ss_sint_t compare(value_type const* s) const stlsoft_throw_0();
00295 ss_sint_t compare(size_type pos, size_type cch, class_type const& rhs, size_type posRhs, size_type cchRhs) const stlsoft_throw_0();
00297 ss_sint_t compare(size_type pos, size_type cch, class_type const& rhs) const stlsoft_throw_0();
00299 ss_sint_t compare(class_type const& rhs) const stlsoft_throw_0();
00301
00304 public:
00305 #if 0
00307 reference operator [](size_type index);
00308 #endif
00314 const_reference operator [](size_type index) const;
00315
00316 #ifdef STLSOFT_CF_EXCEPTION_SUPPORT
00320 const_reference at(size_type index) const;
00321 #endif
00322
00331 value_type const *c_str() const;
00332 #if 0
00338 value_type const *c_str(ss_bool_t bRefresh) const;
00339 #endif
00341 value_type const *data() const stlsoft_throw_0();
00343 value_type const *base() const stlsoft_throw_0();
00344
00345 #if 0
00349 reference front();
00353 reference back();
00354 #endif
00358 const_reference front() const;
00362 const_reference back() const;
00363
00365 size_type copy(value_type *dest, size_type cch, size_type pos = 0) const;
00367
00370 public:
00374 const_iterator begin() const;
00378 const_iterator end() const;
00379 #if 0
00383 iterator begin();
00387 iterator end();
00388 #endif
00389
00390 #if defined(STLSOFT_LF_BIDIRECTIONAL_ITERATOR_SUPPORT)
00394 const_reverse_iterator rbegin() const;
00398 const_reverse_iterator rend() const;
00399 #if 0
00403 reverse_iterator rbegin();
00407 reverse_iterator rend();
00408 #endif
00409 #endif
00411
00414 #ifdef STLSOFT_UNITTEST
00415 public:
00416 #else
00417 private:
00418 #endif
00419 ss_bool_t is_valid() const;
00420
00423 private:
00424
00425 static char_type const* empty_string_();
00426
00427
00428 static ss_sint_t compare_(char_type const* lhs, size_type lhs_len, char_type const* rhs, size_type rhs_len);
00429
00430
00431 void close_() stlsoft_throw_0();
00432
00433
00434 void close_set_null_() stlsoft_throw_0();
00436
00439 private:
00440 size_type m_length;
00441 char_type const* m_base;
00442 char_type *m_cstr;
00444 };
00445
00446
00447
00448
00449
00450 #ifdef STLSOFT_CF_TEMPLATE_CLASS_DEFAULT_CLASS_ARGUMENT_SUPPORT
00451 typedef basic_string_view<ss_char_a_t> string_view;
00452 typedef basic_string_view<ss_char_w_t> wstring_view;
00453 #else
00454 typedef basic_string_view<ss_char_a_t
00455 , stlsoft_char_traits<ss_char_a_t>
00456 , allocator_selector<ss_char_a_t>::allocator_type
00457 > string_view;
00458 typedef basic_string_view<ss_char_w_t
00459 , stlsoft_char_traits<ss_char_w_t>
00460 , allocator_selector<ss_char_w_t>::allocator_type
00461 > wstring_view;
00462 #endif
00463
00464
00465
00466
00467
00470 # ifdef STLSOFT_CF_TEMPLATE_PARTIAL_SPECIALISATION_SUPPORT
00471 template< ss_typename_param_k C
00472 , ss_typename_param_k T
00473 , ss_typename_param_k A
00474 >
00475 struct string_traits<basic_string_view<C, T, A> >
00476 {
00477
00478
00479 typedef basic_string_view<C, T, A> string_type_;
00480 typedef ss_typename_type_k string_type_::value_type char_type;
00481 typedef ss_typename_type_k string_type_::size_type size_type;
00482 typedef char_type const const_char_type;
00483 typedef string_type_ string_type;
00484 typedef string_type_ value_type;
00485
00486 typedef ss_typename_type_k string_type::const_pointer const_pointer;
00487
00488 typedef ss_typename_type_k string_type::const_iterator const_iterator;
00489 #if defined(STLSOFT_LF_BIDIRECTIONAL_ITERATOR_SUPPORT)
00490
00491 typedef ss_typename_type_k string_type::const_reverse_iterator const_reverse_iterator;
00492 #endif
00493 enum
00494 {
00495 is_pointer = false
00496 , is_pointer_to_const = false
00497 , char_type_size = sizeof(char_type)
00498 };
00499
00500 static string_type empty_string()
00501 {
00502 return string_type();
00503 }
00504 static string_type construct(string_type const& src, size_type pos, size_type len)
00505 {
00506 return string_type(src, pos, len);
00507 }
00508 # ifdef STLSOFT_CF_MEMBER_TEMPLATE_FUNCTION_SUPPORT
00509 template <ss_typename_param_k I>
00510 static string_type &assign_inplace(string_type &str, I first, I last)
00511 # else
00512 static string_type &assign_inplace(string_type &str, const_iterator first, const_iterator last)
00513 # endif
00514 {
00515
00516 return (str = string_type(first, last), str);
00517 }
00518 };
00519 # else
00520 STLSOFT_TEMPLATE_SPECIALISATION
00521 struct string_traits<string_view>
00522 {
00523 typedef string_view value_type;
00524 typedef value_type::value_type char_type;
00525 typedef value_type::size_type size_type;
00526 typedef char_type const const_char_type;
00527 typedef value_type string_type;
00528
00529 typedef string_type::const_pointer const_pointer;
00530
00531 typedef string_type::const_iterator const_iterator;
00532 #if defined(STLSOFT_LF_BIDIRECTIONAL_ITERATOR_SUPPORT)
00533
00534 typedef string_type::const_reverse_iterator const_reverse_iterator;
00535 #endif
00536 enum
00537 {
00538 is_pointer = false
00539 , is_pointer_to_const = false
00540 , char_type_size = sizeof(char_type)
00541 };
00542
00543 static string_type empty_string()
00544 {
00545 return string_type();
00546 }
00547 static string_type construct(string_type const& src, size_type pos, size_type len)
00548 {
00549 return string_type(src, pos, len);
00550 }
00551 # ifdef STLSOFT_CF_MEMBER_TEMPLATE_FUNCTION_SUPPORT
00552 template <ss_typename_param_k I>
00553 static string_type &assign_inplace(string_type &str, I first, I last)
00554 # else
00555 static string_type &assign_inplace(string_type &str, const_iterator first, const_iterator last)
00556 # endif
00557 {
00558
00559 return (str = string_type(first, last), str);
00560 }
00561 };
00562
00563 STLSOFT_TEMPLATE_SPECIALISATION
00564 struct string_traits<wstring_view>
00565 {
00566 typedef wstring_view value_type;
00567 typedef value_type::value_type char_type;
00568 typedef value_type::size_type size_type;
00569 typedef char_type const const_char_type;
00570 typedef value_type string_type;
00571
00572 typedef string_type::const_pointer const_pointer;
00573
00574 typedef string_type::const_iterator const_iterator;
00575 #if defined(STLSOFT_LF_BIDIRECTIONAL_ITERATOR_SUPPORT)
00576
00577 typedef string_type::const_reverse_iterator const_reverse_iterator;
00578 #endif
00579 enum
00580 {
00581 is_pointer = false
00582 , is_pointer_to_const = false
00583 , char_type_size = sizeof(char_type)
00584 };
00585
00586 static string_type empty_string()
00587 {
00588 return string_type();
00589 }
00590 static string_type construct(string_type const& src, size_type pos, size_type len)
00591 {
00592 return string_type(src, pos, len);
00593 }
00594 # ifdef STLSOFT_CF_MEMBER_TEMPLATE_FUNCTION_SUPPORT
00595 template <ss_typename_param_k I>
00596 static string_type &assign_inplace(string_type &str, I first, I last)
00597 # else
00598 static string_type &assign_inplace(string_type &str, const_iterator first, const_iterator last)
00599 # endif
00600 {
00601
00602 return (str = string_type(first, last), str);
00603 }
00604 };
00605 # endif
00606
00607
00608
00609
00610
00611 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00612
00613
00614
00615 template< ss_typename_param_k C
00616 , ss_typename_param_k T
00617 , ss_typename_param_k A
00618 >
00619 inline ss_bool_t operator ==(basic_string_view<C, T, A> const& lhs, basic_string_view<C, T, A> const& rhs)
00620 {
00621 return lhs.equal(rhs);
00622 }
00623
00624 template< ss_typename_param_k C
00625 , ss_typename_param_k T
00626 , ss_typename_param_k A
00627 >
00628 #ifdef STLSOFT_CF_TEMPLATE_OUTOFCLASSFN_QUALIFIED_TYPE_SUPPORT
00629 inline ss_bool_t operator ==(basic_string_view<C, T, A> const& lhs, ss_typename_type_k basic_string_view<C, T, A>::char_type const* rhs)
00630 #else
00631 inline ss_bool_t operator ==(basic_string_view<C, T, A> const& lhs, C const* rhs)
00632 #endif
00633 {
00634 typedef ss_typename_type_k basic_string_view<C, T, A>::size_type size_type;
00635 typedef ss_typename_type_k basic_string_view<C, T, A>::traits_type traits_type;
00636
00637 size_type rhs_len = (NULL == rhs) ? 0 : traits_type::length(rhs);
00638
00639 return lhs.equal(rhs, rhs_len);
00640 }
00641
00642 template< ss_typename_param_k C
00643 , ss_typename_param_k T
00644 , ss_typename_param_k A
00645 >
00646 #ifdef STLSOFT_CF_TEMPLATE_OUTOFCLASSFN_QUALIFIED_TYPE_SUPPORT
00647 inline ss_bool_t operator ==(ss_typename_type_k basic_string_view<C, T, A>::char_type const* lhs, basic_string_view<C, T, A> const& rhs)
00648 #else
00649 inline ss_bool_t operator ==(C *lhs, basic_string_view<C, T, A> const& rhs)
00650 #endif
00651 {
00652 typedef ss_typename_type_k basic_string_view<C, T, A>::size_type size_type;
00653 typedef ss_typename_type_k basic_string_view<C, T, A>::traits_type traits_type;
00654
00655 size_type lhs_len = (NULL == lhs) ? 0 : traits_type::length(lhs);
00656
00657 return rhs.equal(lhs, lhs_len);
00658 }
00659
00660
00661
00662 template< ss_typename_param_k C
00663 , ss_typename_param_k T
00664 , ss_typename_param_k A
00665 >
00666 inline ss_bool_t operator !=(basic_string_view<C, T, A> const& lhs, basic_string_view<C, T, A> const& rhs)
00667 {
00668 return !lhs.equal(rhs);
00669 }
00670 template< ss_typename_param_k C
00671 , ss_typename_param_k T
00672 , ss_typename_param_k A
00673 >
00674 #ifdef STLSOFT_CF_TEMPLATE_OUTOFCLASSFN_QUALIFIED_TYPE_SUPPORT
00675 inline ss_bool_t operator !=(basic_string_view<C, T, A> const& lhs, ss_typename_type_k basic_string_view<C, T, A>::char_type const* rhs)
00676 #else
00677 inline ss_bool_t operator !=(basic_string_view<C, T, A> const& lhs, C const* rhs)
00678 #endif
00679 {
00680 typedef ss_typename_type_k basic_string_view<C, T, A>::size_type size_type;
00681 typedef ss_typename_type_k basic_string_view<C, T, A>::traits_type traits_type;
00682
00683 size_type rhs_len = (NULL == rhs) ? 0 : traits_type::length(rhs);
00684
00685 return !lhs.equal(rhs, rhs_len);
00686 }
00687 template< ss_typename_param_k C
00688 , ss_typename_param_k T
00689 , ss_typename_param_k A
00690 >
00691 #ifdef STLSOFT_CF_TEMPLATE_OUTOFCLASSFN_QUALIFIED_TYPE_SUPPORT
00692 inline ss_bool_t operator !=(ss_typename_type_k basic_string_view<C, T, A>::char_type const* lhs, basic_string_view<C, T, A> const& rhs)
00693 #else
00694 inline ss_bool_t operator !=(C const* lhs, basic_string_view<C, T, A> const& rhs)
00695 #endif
00696 {
00697 typedef ss_typename_type_k basic_string_view<C, T, A>::size_type size_type;
00698 typedef ss_typename_type_k basic_string_view<C, T, A>::traits_type traits_type;
00699
00700 size_type lhs_len = (NULL == lhs) ? 0 : traits_type::length(lhs);
00701
00702 return !rhs.equal(lhs, lhs_len);
00703 }
00704
00705
00706
00707 template< ss_typename_param_k C
00708 , ss_typename_param_k T
00709 , ss_typename_param_k A
00710 >
00711 inline ss_bool_t operator <(basic_string_view<C, T, A> const& lhs, basic_string_view<C, T, A> const& rhs)
00712 {
00713 return lhs.compare(rhs) < 0;
00714 }
00715
00716 template< ss_typename_param_k C
00717 , ss_typename_param_k T
00718 , ss_typename_param_k A
00719 >
00720 #ifdef STLSOFT_CF_TEMPLATE_OUTOFCLASSFN_QUALIFIED_TYPE_SUPPORT
00721 inline ss_bool_t operator <(basic_string_view<C, T, A> const& lhs, ss_typename_type_k basic_string_view<C, T, A>::char_type const* rhs)
00722 #else
00723 inline ss_bool_t operator <(basic_string_view<C, T, A> const& lhs, C const* rhs)
00724 #endif
00725 {
00726 return lhs.compare(rhs) < 0;
00727 }
00728
00729 template< ss_typename_param_k C
00730 , ss_typename_param_k T
00731 , ss_typename_param_k A
00732 >
00733 #ifdef STLSOFT_CF_TEMPLATE_OUTOFCLASSFN_QUALIFIED_TYPE_SUPPORT
00734 inline ss_bool_t operator <(ss_typename_type_k basic_string_view<C, T, A>::char_type const* lhs, basic_string_view<C, T, A> const& rhs)
00735 #else
00736 inline ss_bool_t operator <(C const* lhs, basic_string_view<C, T, A> const& rhs)
00737 #endif
00738 {
00739 return rhs.compare(lhs) > 0;
00740 }
00741
00742
00743
00744 template< ss_typename_param_k C
00745 , ss_typename_param_k T
00746 , ss_typename_param_k A
00747 >
00748 inline ss_bool_t operator <=(basic_string_view<C, T, A> const& lhs, basic_string_view<C, T, A> const& rhs)
00749 {
00750 return lhs.compare(rhs) <= 0;
00751 }
00752 template< ss_typename_param_k C
00753 , ss_typename_param_k T
00754 , ss_typename_param_k A
00755 >
00756 #ifdef STLSOFT_CF_TEMPLATE_OUTOFCLASSFN_QUALIFIED_TYPE_SUPPORT
00757 inline ss_bool_t operator <=(basic_string_view<C, T, A> const& lhs, ss_typename_type_k basic_string_view<C, T, A>::char_type const* rhs)
00758 #else
00759 inline ss_bool_t operator <=(basic_string_view<C, T, A> const& lhs, C const* rhs)
00760 #endif
00761 {
00762 return lhs.compare(rhs) <= 0;
00763 }
00764 template< ss_typename_param_k C
00765 , ss_typename_param_k T
00766 , ss_typename_param_k A
00767 >
00768 #ifdef STLSOFT_CF_TEMPLATE_OUTOFCLASSFN_QUALIFIED_TYPE_SUPPORT
00769 inline ss_bool_t operator <=(ss_typename_type_k basic_string_view<C, T, A>::char_type const* lhs, basic_string_view<C, T, A> const& rhs)
00770 #else
00771 inline ss_bool_t operator <=(C const* lhs, basic_string_view<C, T, A> const& rhs)
00772 #endif
00773 {
00774 return rhs.compare(lhs) >= 0;
00775 }
00776
00777
00778
00779 template< ss_typename_param_k C
00780 , ss_typename_param_k T
00781 , ss_typename_param_k A
00782 >
00783 inline ss_bool_t operator >(basic_string_view<C, T, A> const& lhs, basic_string_view<C, T, A> const& rhs)
00784 {
00785 return lhs.compare(rhs) > 0;
00786 }
00787 template< ss_typename_param_k C
00788 , ss_typename_param_k T
00789 , ss_typename_param_k A
00790 >
00791 #ifdef STLSOFT_CF_TEMPLATE_OUTOFCLASSFN_QUALIFIED_TYPE_SUPPORT
00792 inline ss_bool_t operator >(basic_string_view<C, T, A> const& lhs, ss_typename_type_k basic_string_view<C, T, A>::char_type const* rhs)
00793 #else
00794 inline ss_bool_t operator >(basic_string_view<C, T, A> const& lhs, C const* rhs)
00795 #endif
00796 {
00797 return lhs.compare(rhs) > 0;
00798 }
00799 template< ss_typename_param_k C
00800 , ss_typename_param_k T
00801 , ss_typename_param_k A
00802 >
00803 #ifdef STLSOFT_CF_TEMPLATE_OUTOFCLASSFN_QUALIFIED_TYPE_SUPPORT
00804 inline ss_bool_t operator >(ss_typename_type_k basic_string_view<C, T, A>::char_type const* lhs, basic_string_view<C, T, A> const& rhs)
00805 #else
00806 inline ss_bool_t operator >(C const* lhs, basic_string_view<C, T, A> const& rhs)
00807 #endif
00808 {
00809 return rhs.compare(lhs) < 0;
00810 }
00811
00812
00813
00814 template< ss_typename_param_k C
00815 , ss_typename_param_k T
00816 , ss_typename_param_k A
00817 >
00818 inline ss_bool_t operator >=(basic_string_view<C, T, A> const& lhs, basic_string_view<C, T, A> const& rhs)
00819 {
00820 return lhs.compare(rhs) >= 0;
00821 }
00822 template< ss_typename_param_k C
00823 , ss_typename_param_k T
00824 , ss_typename_param_k A
00825 >
00826 #ifdef STLSOFT_CF_TEMPLATE_OUTOFCLASSFN_QUALIFIED_TYPE_SUPPORT
00827 inline ss_bool_t operator >=(basic_string_view<C, T, A> const& lhs, ss_typename_type_k basic_string_view<C, T, A>::char_type const* rhs)
00828 #else
00829 inline ss_bool_t operator >=(basic_string_view<C, T, A> const& lhs, C const* rhs)
00830 #endif
00831 {
00832 return lhs.compare(rhs) >= 0;
00833 }
00834 template< ss_typename_param_k C
00835 , ss_typename_param_k T
00836 , ss_typename_param_k A
00837 >
00838 #ifdef STLSOFT_CF_TEMPLATE_OUTOFCLASSFN_QUALIFIED_TYPE_SUPPORT
00839 inline ss_bool_t operator >=(ss_typename_type_k basic_string_view<C, T, A>::char_type const* lhs, basic_string_view<C, T, A> const& rhs)
00840 #else
00841 inline ss_bool_t operator >=(C const* lhs, basic_string_view<C, T, A> const& rhs)
00842 #endif
00843 {
00844 return rhs.compare(lhs) <= 0;
00845 }
00846
00847 #endif
00848
00849
00850
00851
00852
00853 template< ss_typename_param_k S
00854 , ss_typename_param_k C
00855 , ss_typename_param_k T
00856 , ss_typename_param_k A
00857 >
00858 inline S& operator <<(S& s, basic_string_view<C, T, A> const& str)
00859 {
00860 s.write(str.data(), static_cast<ss_streamoff_t>(str.length()));
00861
00862 return s;
00863 }
00864
00865
00866
00867
00868
00869 #ifdef STLSOFT_UNITTEST
00870 # include "./unittest/string_view_unittest_.h"
00871 #endif
00872
00873
00874
00875
00876
00877 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00878
00879
00880
00881 template< ss_typename_param_k C
00882 , ss_typename_param_k T
00883 , ss_typename_param_k A
00884 >
00885 inline ss_typename_type_ret_k basic_string_view<C, T, A>::char_type const* basic_string_view<C, T, A>::empty_string_()
00886 {
00887
00888
00889
00890 static char_type s_empty[1];
00891
00892 STLSOFT_ASSERT(s_empty[0] == '\0');
00893
00894 return s_empty;
00895 }
00896
00897 template< ss_typename_param_k C
00898 , ss_typename_param_k T
00899 , ss_typename_param_k A
00900 >
00901 inline ss_sint_t basic_string_view<C, T, A>::compare_( ss_typename_type_k basic_string_view<C, T, A>::value_type const* lhs
00902 , ss_typename_type_k basic_string_view<C, T, A>::size_type lhs_len
00903 , ss_typename_type_k basic_string_view<C, T, A>::value_type const* rhs
00904 , ss_typename_type_k basic_string_view<C, T, A>::size_type rhs_len)
00905 {
00906 size_type cmp_len = (lhs_len < rhs_len) ? lhs_len : rhs_len;
00907 ss_int_t result = traits_type::compare(lhs, rhs, cmp_len);
00908
00909 if(0 == result)
00910 {
00911 result = static_cast<ss_int_t>(lhs_len) - static_cast<ss_int_t>(rhs_len);
00912 }
00913
00914 return result;
00915 }
00916
00917 template< ss_typename_param_k C
00918 , ss_typename_param_k T
00919 , ss_typename_param_k A
00920 >
00921 inline void basic_string_view<C, T, A>::close_() stlsoft_throw_0()
00922 {
00923 STLSOFT_ASSERT(NULL != m_cstr);
00924
00925 allocator_type &ator = *this;
00926
00927 ator.deallocate(m_cstr, 1 + m_length);
00928
00929 #if defined(STLSOFT_COMPILER_IS_BORLAND)
00930 STLSOFT_SUPPRESS_UNUSED(ator);
00931 #endif
00932 }
00933
00934 template< ss_typename_param_k C
00935 , ss_typename_param_k T
00936 , ss_typename_param_k A
00937 >
00938 inline void basic_string_view<C, T, A>::close_set_null_() stlsoft_throw_0()
00939 {
00940 if(NULL != m_cstr)
00941 {
00942 close_();
00943
00944 m_cstr = NULL;
00945 }
00946 }
00947
00952 template< ss_typename_param_k C
00953 , ss_typename_param_k T
00954 , ss_typename_param_k A
00955 >
00956 inline ss_bool_t basic_string_view<C, T, A>::is_valid() const
00957 {
00958
00959
00960 if( 0 == m_length &&
00961 NULL != m_cstr)
00962 {
00963 return false;
00964 }
00965
00966 if( 0 != m_length &&
00967 NULL == m_base)
00968 {
00969 return false;
00970 }
00971
00972 return true;
00973 }
00974
00975
00976
00977
00978 template< ss_typename_param_k C
00979 , ss_typename_param_k T
00980 , ss_typename_param_k A
00981 >
00982 inline basic_string_view<C, T, A>::basic_string_view()
00983 : m_length(0)
00984 , m_base(NULL)
00985 , m_cstr(NULL)
00986 {
00987 STLSOFT_ASSERT(is_valid());
00988 }
00989
00990 template< ss_typename_param_k C
00991 , ss_typename_param_k T
00992 , ss_typename_param_k A
00993 >
00994 inline basic_string_view<C, T, A>::basic_string_view(basic_string_view<C, T, A> const& rhs)
00995 : m_length(rhs.m_length)
00996 , m_base(rhs.m_base)
00997 , m_cstr(NULL)
00998 {
00999 STLSOFT_ASSERT(is_valid());
01000 }
01001
01002 template< ss_typename_param_k C
01003 , ss_typename_param_k T
01004 , ss_typename_param_k A
01005 >
01006 inline basic_string_view<C, T, A>::basic_string_view(basic_string_view<C, T, A> const& rhs, ss_typename_type_k basic_string_view<C, T, A>::size_type pos)
01007 : m_length(rhs.m_length - pos)
01008 , m_base(&rhs[pos])
01009 , m_cstr(NULL)
01010 {
01011 STLSOFT_ASSERT(pos <= rhs.m_length);
01012
01013 STLSOFT_ASSERT(is_valid());
01014 }
01015
01016 template< ss_typename_param_k C
01017 , ss_typename_param_k T
01018 , ss_typename_param_k A
01019 >
01020 inline basic_string_view<C, T, A>::basic_string_view( basic_string_view<C, T, A> const& rhs
01021 , ss_typename_type_k basic_string_view<C, T, A>::size_type pos
01022 , ss_typename_type_k basic_string_view<C, T, A>::size_type cch)
01023 : m_length(cch)
01024 , m_base(&rhs[pos])
01025 , m_cstr(NULL)
01026 {
01027 STLSOFT_ASSERT(is_valid());
01028 }
01029
01030 template< ss_typename_param_k C
01031 , ss_typename_param_k T
01032 , ss_typename_param_k A
01033 >
01034 inline basic_string_view<C, T, A>::basic_string_view(ss_typename_type_k basic_string_view<C, T, A>::char_type const* s)
01035 : m_length(T::length(s))
01036 , m_base(s)
01037 , m_cstr(NULL)
01038 {
01039 STLSOFT_ASSERT(is_valid());
01040 }
01041
01042 template< ss_typename_param_k C
01043 , ss_typename_param_k T
01044 , ss_typename_param_k A
01045 >
01046 inline basic_string_view<C, T, A>::basic_string_view( ss_typename_type_k basic_string_view<C, T, A>::char_type const* s
01047 , ss_typename_type_k basic_string_view<C, T, A>::size_type cch)
01048 : m_length(cch)
01049 , m_base(s)
01050 , m_cstr(NULL)
01051 {
01052 STLSOFT_ASSERT(is_valid());
01053 }
01054
01055 template< ss_typename_param_k C
01056 , ss_typename_param_k T
01057 , ss_typename_param_k A
01058 >
01059 inline basic_string_view<C, T, A>::basic_string_view( ss_typename_type_k basic_string_view<C, T, A>::char_type const* first
01060 , ss_typename_type_k basic_string_view<C, T, A>::char_type const* last)
01061 : m_length(static_cast<size_type>(last - first))
01062 , m_base(first)
01063 , m_cstr(NULL)
01064 {
01065 STLSOFT_ASSERT(first <= last);
01066
01067 STLSOFT_ASSERT(is_valid());
01068 }
01069
01070 template< ss_typename_param_k C
01071 , ss_typename_param_k T
01072 , ss_typename_param_k A
01073 >
01074 inline basic_string_view<C, T, A>::~basic_string_view() stlsoft_throw_0()
01075 {
01076 STLSOFT_ASSERT(is_valid());
01077
01078 if(NULL != m_cstr)
01079 {
01080 close_();
01081 }
01082 }
01083
01084 template< ss_typename_param_k C
01085 , ss_typename_param_k T
01086 , ss_typename_param_k A
01087 >
01088 inline basic_string_view<C, T, A> &basic_string_view<C, T, A>::operator =(basic_string_view<C, T, A> const& rhs)
01089 {
01090 close_set_null_();
01091
01092 m_length = rhs.m_length;
01093 m_base = rhs.m_base;
01094
01095 return *this;
01096 }
01097
01098
01099
01100 template< ss_typename_param_k C
01101 , ss_typename_param_k T
01102 , ss_typename_param_k A
01103 >
01104 inline void basic_string_view<C, T, A>::swap(ss_typename_type_k basic_string_view<C, T, A>::class_type& rhs) stlsoft_throw_0()
01105 {
01106 STLSOFT_ASSERT(is_valid());
01107
01108 std_swap(m_length, rhs.m_length);
01109 std_swap(m_base, rhs.m_base);
01110 std_swap(m_cstr, rhs.m_cstr);
01111
01112 STLSOFT_ASSERT(is_valid());
01113 }
01114
01115 template< ss_typename_param_k C
01116 , ss_typename_param_k T
01117 , ss_typename_param_k A
01118 >
01119 inline void basic_string_view<C, T, A>::clear() stlsoft_throw_0()
01120 {
01121 STLSOFT_ASSERT(is_valid());
01122
01123 close_set_null_();
01124
01125 m_length = 0;
01126 m_base = NULL;
01127
01128 STLSOFT_ASSERT(is_valid());
01129 }
01130
01131 template< ss_typename_param_k C
01132 , ss_typename_param_k T
01133 , ss_typename_param_k A
01134 >
01135 inline void basic_string_view<C, T, A>::refresh() stlsoft_throw_0()
01136 {
01137 STLSOFT_ASSERT(is_valid());
01138
01139 close_set_null_();
01140
01141 STLSOFT_ASSERT(is_valid());
01142 }
01143
01144
01145
01146 template< ss_typename_param_k C
01147 , ss_typename_param_k T
01148 , ss_typename_param_k A
01149 >
01150 inline ss_typename_type_ret_k basic_string_view<C, T, A>::size_type basic_string_view<C, T, A>::size() const stlsoft_throw_0()
01151 {
01152 STLSOFT_ASSERT(is_valid());
01153
01154 return m_length;
01155 }
01156
01157 template< ss_typename_param_k C
01158 , ss_typename_param_k T
01159 , ss_typename_param_k A
01160 >
01161 inline ss_typename_type_ret_k basic_string_view<C, T, A>::size_type basic_string_view<C, T, A>::max_size() stlsoft_throw_0()
01162 {
01163 return static_cast<size_type>(-1) / sizeof(char_type);
01164 }
01165
01166
01167
01168 template< ss_typename_param_k C
01169 , ss_typename_param_k T
01170 , ss_typename_param_k A
01171 >
01172 inline ss_typename_type_ret_k basic_string_view<C, T, A>::size_type basic_string_view<C, T, A>::length() const stlsoft_throw_0()
01173 {
01174 STLSOFT_ASSERT(is_valid());
01175
01176 return m_length;
01177 }
01178
01179 template< ss_typename_param_k C
01180 , ss_typename_param_k T
01181 , ss_typename_param_k A
01182 >
01183 inline ss_typename_type_ret_k basic_string_view<C, T, A>::size_type basic_string_view<C, T, A>::capacity() const stlsoft_throw_0()
01184 {
01185 STLSOFT_ASSERT(is_valid());
01186
01187 return m_length;
01188 }
01189
01190 template< ss_typename_param_k C
01191 , ss_typename_param_k T
01192 , ss_typename_param_k A
01193 >
01194 inline ss_bool_t basic_string_view<C, T, A>::empty() const stlsoft_throw_0()
01195 {
01196 STLSOFT_ASSERT(is_valid());
01197
01198 return 0 == size();
01199 }
01200
01201 template< ss_typename_param_k C
01202 , ss_typename_param_k T
01203 , ss_typename_param_k A
01204 >
01205 inline ss_typename_type_ret_k basic_string_view<C, T, A>::allocator_type basic_string_view<C, T, A>::get_allocator() const
01206 {
01207 return *this;
01208 }
01209
01210
01211
01212 template< ss_typename_param_k C
01213 , ss_typename_param_k T
01214 , ss_typename_param_k A
01215 >
01216 inline ss_bool_t basic_string_view<C, T, A>::equal(ss_typename_type_k basic_string_view<C, T, A>::class_type const& rhs) const stlsoft_throw_0()
01217 {
01218 STLSOFT_ASSERT(is_valid());
01219
01220 return (m_length == rhs.m_length) && ((m_base == rhs.m_base) || 0 == compare(rhs));
01221 }
01222
01223 template< ss_typename_param_k C
01224 , ss_typename_param_k T
01225 , ss_typename_param_k A
01226 >
01227 inline ss_bool_t basic_string_view<C, T, A>::equal(ss_typename_type_k basic_string_view<C, T, A>::value_type const* rhs, ss_typename_type_k basic_string_view<C, T, A>::size_type cchRhs) const stlsoft_throw_0()
01228 {
01229 STLSOFT_ASSERT(is_valid());
01230
01231 return (m_length == cchRhs) && ((m_base == rhs) || 0 == compare_(m_base, m_length, rhs, cchRhs));
01232 }
01233
01234
01235 template< ss_typename_param_k C
01236 , ss_typename_param_k T
01237 , ss_typename_param_k A
01238 >
01239 inline ss_sint_t basic_string_view<C, T, A>::compare( ss_typename_type_k basic_string_view<C, T, A>::size_type pos
01240 , ss_typename_type_k basic_string_view<C, T, A>::size_type cch
01241 , ss_typename_type_k basic_string_view<C, T, A>::value_type const *rhs
01242 , ss_typename_type_k basic_string_view<C, T, A>::size_type cchRhs) const stlsoft_throw_0()
01243 {
01244 STLSOFT_ASSERT(is_valid());
01245
01246 size_type lhs_len = length();
01247
01248 if(!(pos < lhs_len))
01249 {
01250 pos = lhs_len;
01251 }
01252 else
01253 {
01254 lhs_len -= pos;
01255 }
01256
01257 if(cch < lhs_len)
01258 {
01259 lhs_len = cch;
01260 }
01261
01262 size_type rhs_len = (NULL == rhs) ? 0 : traits_type::length(rhs);
01263
01264 if(cchRhs < rhs_len)
01265 {
01266 rhs_len = cchRhs;
01267 }
01268
01269 STLSOFT_ASSERT(is_valid());
01270
01271 return compare_(m_base + pos, lhs_len, rhs, rhs_len);
01272 }
01273
01274 template< ss_typename_param_k C
01275 , ss_typename_param_k T
01276 , ss_typename_param_k A
01277 >
01278 inline ss_sint_t basic_string_view<C, T, A>::compare( ss_typename_type_k basic_string_view<C, T, A>::size_type pos
01279 , ss_typename_type_k basic_string_view<C, T, A>::size_type cch
01280 , ss_typename_type_k basic_string_view<C, T, A>::value_type const* rhs) const stlsoft_throw_0()
01281 {
01282 STLSOFT_ASSERT(is_valid());
01283
01284 size_type lhs_len = length();
01285
01286 if(!(pos < lhs_len))
01287 {
01288 pos = lhs_len;
01289 }
01290 else
01291 {
01292 lhs_len -= pos;
01293 }
01294
01295 if(cch < lhs_len)
01296 {
01297 lhs_len = cch;
01298 }
01299
01300 size_type rhs_len = (NULL == rhs) ? 0 : traits_type::length(rhs);
01301
01302 STLSOFT_ASSERT(is_valid());
01303
01304 return compare_(m_base + pos, lhs_len, rhs, rhs_len);
01305 }
01306
01307 template< ss_typename_param_k C
01308 , ss_typename_param_k T
01309 , ss_typename_param_k A
01310 >
01311 inline ss_sint_t basic_string_view<C, T, A>::compare(ss_typename_type_k basic_string_view<C, T, A>::value_type const* rhs) const stlsoft_throw_0()
01312 {
01313 STLSOFT_ASSERT(is_valid());
01314
01315 size_type lhs_len = length();
01316 size_type rhs_len = (NULL == rhs) ? 0 : traits_type::length(rhs);
01317
01318 return compare_(m_base, lhs_len, rhs, rhs_len);
01319 }
01320
01321 template< ss_typename_param_k C
01322 , ss_typename_param_k T
01323 , ss_typename_param_k A
01324 >
01325 inline ss_sint_t basic_string_view<C, T, A>::compare( ss_typename_type_k basic_string_view<C, T, A>::size_type pos
01326 , ss_typename_type_k basic_string_view<C, T, A>::size_type cch
01327 , ss_typename_type_k basic_string_view<C, T, A>::class_type const& rhs
01328 , ss_typename_type_k basic_string_view<C, T, A>::size_type posRhs
01329 , ss_typename_type_k basic_string_view<C, T, A>::size_type cchRhs) const stlsoft_throw_0()
01330 {
01331 STLSOFT_ASSERT(is_valid());
01332
01333 size_type lhs_len = length();
01334
01335 if(!(pos < lhs_len))
01336 {
01337 pos = lhs_len;
01338 }
01339 else
01340 {
01341 lhs_len -= pos;
01342 }
01343
01344 if(cch < lhs_len)
01345 {
01346 lhs_len = cch;
01347 }
01348
01349 size_type rhs_len = rhs.length();
01350
01351 if(!(posRhs < rhs_len))
01352 {
01353 posRhs = rhs_len;
01354 }
01355 else
01356 {
01357 rhs_len -= posRhs;
01358 }
01359
01360 if(cchRhs < rhs_len)
01361 {
01362 rhs_len = cchRhs;
01363 }
01364
01365 STLSOFT_ASSERT(is_valid());
01366
01367 return compare_(m_base + pos, lhs_len, rhs.m_base + posRhs, rhs_len);
01368 }
01369
01370 template< ss_typename_param_k C
01371 , ss_typename_param_k T
01372 , ss_typename_param_k A
01373 >
01374 inline ss_sint_t basic_string_view<C, T, A>::compare( ss_typename_type_k basic_string_view<C, T, A>::size_type pos
01375 , ss_typename_type_k basic_string_view<C, T, A>::size_type cch
01376 , ss_typename_type_k basic_string_view<C, T, A>::class_type const& rhs) const stlsoft_throw_0()
01377 {
01378 STLSOFT_ASSERT(is_valid());
01379
01380 size_type lhs_len = length();
01381
01382 if(!(pos < lhs_len))
01383 {
01384 pos = lhs_len;
01385 }
01386 else
01387 {
01388 lhs_len -= pos;
01389 }
01390
01391 if(cch < lhs_len)
01392 {
01393 lhs_len = cch;
01394 }
01395
01396 size_type rhs_len = rhs.length();
01397
01398 STLSOFT_ASSERT(is_valid());
01399
01400 return compare_(m_base + pos, lhs_len, rhs.m_base, rhs_len);
01401 }
01402
01403 template< ss_typename_param_k C
01404 , ss_typename_param_k T
01405 , ss_typename_param_k A
01406 >
01407 inline ss_sint_t basic_string_view<C, T, A>::compare(ss_typename_type_k basic_string_view<C, T, A>::class_type const& rhs) const stlsoft_throw_0()
01408 {
01409 STLSOFT_ASSERT(is_valid());
01410
01411 size_type lhs_len = length();
01412 size_type rhs_len = rhs.length();
01413
01414 STLSOFT_ASSERT(is_valid());
01415
01416 return compare_(m_base, lhs_len, rhs.m_base, rhs_len);
01417 }
01418
01419
01420
01421 #if 0
01422 template< ss_typename_param_k C
01423 , ss_typename_param_k T
01424 , ss_typename_param_k A
01425 >
01426 inline ss_typename_type_ret_k basic_string_view<C, T, A>::reference basic_string_view<C, T, A>::operator [](ss_typename_type_k basic_string_view<C, T, A>::size_type index)
01427 {
01428 STLSOFT_ASSERT(is_valid());
01429
01430 return m_base[index];
01431 }
01432 #endif
01433
01434 template< ss_typename_param_k C
01435 , ss_typename_param_k T
01436 , ss_typename_param_k A
01437 >
01438 inline ss_typename_type_ret_k basic_string_view<C, T, A>::const_reference basic_string_view<C, T, A>::operator [](ss_typename_type_k basic_string_view<C, T, A>::size_type index) const
01439 {
01440 STLSOFT_MESSAGE_ASSERT("string_view index out of bounds", index <= size());
01441
01442 STLSOFT_ASSERT(is_valid());
01443
01444 return (index == size()) ? *empty_string_() : m_base[index];
01445 }
01446
01447 #ifdef STLSOFT_CF_EXCEPTION_SUPPORT
01448 template< ss_typename_param_k C
01449 , ss_typename_param_k T
01450 , ss_typename_param_k A
01451 >
01452 inline ss_typename_type_ret_k basic_string_view<C, T, A>::const_reference basic_string_view<C, T, A>::at(ss_typename_type_k basic_string_view<C, T, A>::size_type index) const
01453 {
01454 STLSOFT_ASSERT(is_valid());
01455
01456 if(!(index < size()))
01457 {
01458 STLSOFT_THROW_X(stlsoft_ns_qual_std(out_of_range)("index out of range"));
01459 }
01460
01461 STLSOFT_ASSERT(is_valid());
01462
01463 return m_base[index];
01464 }
01465 #endif
01466
01467 template< ss_typename_param_k C
01468 , ss_typename_param_k T
01469 , ss_typename_param_k A
01470 >
01471 inline ss_typename_type_ret_k basic_string_view<C, T, A>::value_type const* basic_string_view<C, T, A>::c_str() const
01472 {
01473 STLSOFT_ASSERT(is_valid());
01474
01475 if(NULL != m_cstr)
01476 {
01477
01478 return m_cstr;
01479 }
01480 else
01481 {
01482 if(0 == m_length)
01483 {
01484 return empty_string_();
01485 }
01486 else
01487 {
01488
01489 allocator_type &ator = const_cast<class_type&>(*this);
01490 char_type *s = ator.allocate(1 + length(), NULL);
01491
01492 STLSOFT_SUPPRESS_UNUSED(ator);
01493
01494
01495
01496
01497
01498
01499
01500
01501 if(NULL != s)
01502 {
01503 traits_type::copy(s, m_base, m_length);
01504 s[m_length] = '\0';
01505
01506 remove_const(m_cstr) = s;
01507
01508 STLSOFT_ASSERT(is_valid());
01509 }
01510
01511 return m_cstr;
01512 }
01513 }
01514 }
01515
01516 #if 0
01517 template< ss_typename_param_k C
01518 , ss_typename_param_k T
01519 , ss_typename_param_k A
01520 >
01521 inline ss_typename_type_ret_k basic_string_view<C, T, A>::value_type const* basic_string_view<C, T, A>::c_str(ss_bool_t bRefresh) const
01522 {
01523 if(bRefresh)
01524 {
01525 const_cast<class_type*>(this)->refresh();
01526 }
01527
01528 return c_str();
01529 }
01530 #endif
01531
01532 template< ss_typename_param_k C
01533 , ss_typename_param_k T
01534 , ss_typename_param_k A
01535 >
01536 inline ss_typename_type_ret_k basic_string_view<C, T, A>::value_type const* basic_string_view<C, T, A>::data() const stlsoft_throw_0()
01537 {
01538 STLSOFT_ASSERT(is_valid());
01539
01540 return (0 == m_length) ? empty_string_() : m_base;
01541 }
01542
01543 template< ss_typename_param_k C
01544 , ss_typename_param_k T
01545 , ss_typename_param_k A
01546 >
01547 inline ss_typename_type_ret_k basic_string_view<C, T, A>::value_type const* basic_string_view<C, T, A>::base() const stlsoft_throw_0()
01548 {
01549 STLSOFT_ASSERT(is_valid());
01550
01551 return m_base;
01552 }
01553
01554 #if 0
01555 template< ss_typename_param_k C
01556 , ss_typename_param_k T
01557 , ss_typename_param_k A
01558 >
01559 inline ss_typename_type_ret_k basic_string_view<C, T, A>::reference basic_string_view<C, T, A>::front()
01560 {
01561 STLSOFT_ASSERT(is_valid());
01562
01563 return (*this)[0];
01564 }
01565
01566 template< ss_typename_param_k C
01567 , ss_typename_param_k T
01568 , ss_typename_param_k A
01569 >
01570 inline ss_typename_type_ret_k basic_string_view<C, T, A>::reference basic_string_view<C, T, A>::back()
01571 {
01572 STLSOFT_ASSERT(is_valid());
01573
01574 return (*this)[length() - 1];
01575 }
01576 #endif
01577
01578 template< ss_typename_param_k C
01579 , ss_typename_param_k T
01580 , ss_typename_param_k A
01581 >
01582 inline ss_typename_type_ret_k basic_string_view<C, T, A>::const_reference basic_string_view<C, T, A>::front() const
01583 {
01584 STLSOFT_ASSERT(is_valid());
01585
01586 return (*this)[0];
01587 }
01588
01589 template< ss_typename_param_k C
01590 , ss_typename_param_k T
01591 , ss_typename_param_k A
01592 >
01593 inline ss_typename_type_ret_k basic_string_view<C, T, A>::const_reference basic_string_view<C, T, A>::back() const
01594 {
01595 STLSOFT_ASSERT(is_valid());
01596
01597 return (*this)[length() - 1];
01598 }
01599
01600 template< ss_typename_param_k C
01601 , ss_typename_param_k T
01602 , ss_typename_param_k A
01603 >
01604 inline ss_typename_type_ret_k basic_string_view<C, T, A>::size_type basic_string_view<C, T, A>::copy( ss_typename_type_k basic_string_view<C, T, A>::value_type *dest
01605 , ss_typename_type_k basic_string_view<C, T, A>::size_type cch
01606 , ss_typename_type_k basic_string_view<C, T, A>::size_type pos ) const
01607 {
01608 STLSOFT_ASSERT(is_valid());
01609
01610 size_type len = length();
01611
01612 if(pos < len)
01613 {
01614 if(len < pos + cch)
01615 {
01616 cch = len - pos;
01617 }
01618
01619 traits_type::copy(dest, data() + pos, cch);
01620 }
01621 else
01622 {
01623 cch = 0;
01624 }
01625
01626 STLSOFT_ASSERT(is_valid());
01627
01628 return cch;
01629 }
01630
01631
01632
01633
01634 template< ss_typename_param_k C
01635 , ss_typename_param_k T
01636 , ss_typename_param_k A
01637 >
01638 inline ss_typename_type_ret_k basic_string_view<C, T, A>::const_iterator basic_string_view<C, T, A>::begin() const
01639 {
01640 STLSOFT_ASSERT(is_valid());
01641
01642 return m_base;
01643 }
01644
01645 template< ss_typename_param_k C
01646 , ss_typename_param_k T
01647 , ss_typename_param_k A
01648 >
01649 inline ss_typename_type_ret_k basic_string_view<C, T, A>::const_iterator basic_string_view<C, T, A>::end() const
01650 {
01651 STLSOFT_ASSERT(is_valid());
01652
01653 return begin() + m_length;
01654 }
01655
01656 #if 0
01657 template< ss_typename_param_k C
01658 , ss_typename_param_k T
01659 , ss_typename_param_k A
01660 >
01661 inline ss_typename_type_ret_k basic_string_view<C, T, A>::iterator basic_string_view<C, T, A>::begin()
01662 {
01663 STLSOFT_ASSERT(is_valid());
01664
01665 return m_base;
01666 }
01667
01668 template< ss_typename_param_k C
01669 , ss_typename_param_k T
01670 , ss_typename_param_k A
01671 >
01672 inline ss_typename_type_ret_k basic_string_view<C, T, A>::iterator basic_string_view<C, T, A>::end()
01673 {
01674 STLSOFT_ASSERT(is_valid());
01675
01676 return begin() + m_length;
01677 }
01678 #endif
01679
01680 #if defined(STLSOFT_LF_BIDIRECTIONAL_ITERATOR_SUPPORT)
01681 template< ss_typename_param_k C
01682 , ss_typename_param_k T
01683 , ss_typename_param_k A
01684 >
01685 inline ss_typename_type_ret_k basic_string_view<C, T, A>::const_reverse_iterator basic_string_view<C, T, A>::rbegin() const
01686 {
01687 STLSOFT_ASSERT(is_valid());
01688
01689 return const_reverse_iterator(end());
01690 }
01691
01692 template< ss_typename_param_k C
01693 , ss_typename_param_k T
01694 , ss_typename_param_k A
01695 >
01696 inline ss_typename_type_ret_k basic_string_view<C, T, A>::const_reverse_iterator basic_string_view<C, T, A>::rend() const
01697 {
01698 STLSOFT_ASSERT(is_valid());
01699
01700 return const_reverse_iterator(begin());
01701 }
01702
01703 #if 0
01704 template< ss_typename_param_k C
01705 , ss_typename_param_k T
01706 , ss_typename_param_k A
01707 >
01708 inline ss_typename_type_ret_k basic_string_view<C, T, A>::reverse_iterator basic_string_view<C, T, A>::rbegin()
01709 {
01710 STLSOFT_ASSERT(is_valid());
01711
01712 return reverse_iterator(end());
01713 }
01714
01715 template< ss_typename_param_k C
01716 , ss_typename_param_k T
01717 , ss_typename_param_k A
01718 >
01719 inline ss_typename_type_ret_k basic_string_view<C, T, A>::reverse_iterator basic_string_view<C, T, A>::rend()
01720 {
01721 STLSOFT_ASSERT(is_valid());
01722
01723 return reverse_iterator(begin());
01724 }
01725 #endif
01726 #endif
01727
01728 #endif
01729
01730
01731
01732
01733
01734 template< ss_typename_param_k C
01735 , ss_typename_param_k T
01736 , ss_typename_param_k A
01737 >
01738 inline void swap(basic_string_view<C, T, A>& lhs, basic_string_view<C, T, A>& rhs)
01739 {
01740 lhs.swap(rhs);
01741 }
01742
01743
01744
01745
01746
01747
01748
01753 template< ss_typename_param_k C
01754 , ss_typename_param_k T
01755 , ss_typename_param_k A
01756 >
01757 inline C const* c_str_data(stlsoft_ns_qual(basic_string_view)<C, T, A> const& s)
01758 {
01759 return s.data();
01760 }
01761
01762 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
01763
01764 template <ss_typename_param_k T, ss_typename_param_k A>
01765 inline ss_char_a_t const* c_str_data_a(stlsoft_ns_qual(basic_string_view)<ss_char_a_t, T, A> const& s)
01766 {
01767 return s.data();
01768 }
01769 template <ss_typename_param_k T, ss_typename_param_k A>
01770 inline ss_char_w_t const* c_str_data_w(stlsoft_ns_qual(basic_string_view)<ss_char_w_t, T, A> const& s)
01771 {
01772 return s.data();
01773 }
01774
01775 #endif
01776
01777
01778
01783 template< ss_typename_param_k C
01784 , ss_typename_param_k T
01785 , ss_typename_param_k A
01786 >
01787 inline ss_size_t c_str_len(stlsoft_ns_qual(basic_string_view)<C, T, A> const& s)
01788 {
01789 return s.length();
01790 }
01791
01792 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
01793
01794 template <ss_typename_param_k T, ss_typename_param_k A>
01795 inline ss_size_t c_str_len_a(stlsoft_ns_qual(basic_string_view)<ss_char_a_t, T, A> const& s)
01796 {
01797 return s.length();
01798 }
01799 template <ss_typename_param_k T, ss_typename_param_k A>
01800 inline ss_size_t c_str_len_w(stlsoft_ns_qual(basic_string_view)<ss_char_w_t, T, A> const& s)
01801 {
01802 return s.length();
01803 }
01804
01805 #endif
01806
01807
01808
01813 template< ss_typename_param_k C
01814 , ss_typename_param_k T
01815 , ss_typename_param_k A
01816 >
01817 inline C const* c_str_ptr(stlsoft_ns_qual(basic_string_view)<C, T, A> const& s)
01818 {
01819 return s.c_str();
01820 }
01821
01822 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
01823
01824 template <ss_typename_param_k T, ss_typename_param_k A>
01825 inline ss_char_a_t const* c_str_ptr_a(stlsoft_ns_qual(basic_string_view)<ss_char_a_t, T, A> const& s)
01826 {
01827 return s.c_str();
01828 }
01829 template <ss_typename_param_k T, ss_typename_param_k A>
01830 inline ss_char_w_t const* c_str_ptr_w(stlsoft_ns_qual(basic_string_view)<ss_char_w_t, T, A> const& s)
01831 {
01832 return s.c_str();
01833 }
01834
01835 #endif
01836
01837
01838
01843 template< ss_typename_param_k C
01844 , ss_typename_param_k T
01845 , ss_typename_param_k A
01846 >
01847 inline C const* c_str_ptr_null(stlsoft_ns_qual(basic_string_view)<C, T, A> const& s)
01848 {
01849 return (0 != s.length()) ? s.c_str() : NULL;
01850 }
01851
01852 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
01853
01854 template <ss_typename_param_k T, ss_typename_param_k A>
01855 inline ss_char_a_t const* c_str_ptr_null_a(stlsoft_ns_qual(basic_string_view)<ss_char_a_t, T, A> const& s)
01856 {
01857 return (0 != s.length()) ? s.c_str() : NULL;
01858 }
01859 template <ss_typename_param_k T, ss_typename_param_k A>
01860 inline ss_char_w_t const* c_str_ptr_null_w(stlsoft_ns_qual(basic_string_view)<ss_char_w_t, T, A> const& s)
01861 {
01862 return (0 != s.length()) ? s.c_str() : NULL;
01863 }
01864
01865 #endif
01866
01867
01868
01869 #ifndef _STLSOFT_NO_NAMESPACE
01870 }
01871 #endif
01872
01873
01874
01875
01876 #if defined(STLSOFT_CF_std_NAMESPACE)
01877 # if ( ( defined(STLSOFT_COMPILER_IS_INTEL) && \
01878 defined(_MSC_VER))) && \
01879 _MSC_VER < 1310
01880 namespace std
01881 {
01882 template< ss_typename_param_k C
01883 , ss_typename_param_k T
01884 , ss_typename_param_k A
01885 >
01886 inline void swap(stlsoft_ns_qual(basic_string_view)<C, T, A>& lhs, stlsoft_ns_qual(basic_string_view)<C, T, A>& rhs)
01887 {
01888 lhs.swap(rhs);
01889 }
01890 }
01891 # endif
01892 #endif
01893
01894
01895
01896 #endif
01897
01898