/* ///////////////////////////////////////////////////////////////////////////// * File: stlsoft/string_view.hpp * * Purpose: basic_string_view class. * * Created: 16th October 2004 * Updated: 18th March 2005 * * Thanks to: Bjorn Karlsson and Scott Patterson for discussions on various * naming and design issues. Thanks also to Pablo Aguilar for * his eagle eyed reviews of beta code. :-) * * Home: http://stlsoft.org/ * * Copyright (c) 2004-2005, Matthew Wilson and Synesis Software * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * - Redistributions of source code must retain the above copyright notice, this * list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. * - Neither the name(s) of Matthew Wilson and Synesis Software nor the names of * any contributors may be used to endorse or promote products derived from * this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. * * ////////////////////////////////////////////////////////////////////////// */ /// \file stlsoft/string_view.hpp /// /// basic_string_view class. #ifndef STLSOFT_INCL_H_STLSOFT_STRING_VIEW #define STLSOFT_INCL_H_STLSOFT_STRING_VIEW #ifndef __STLSOFT_DOCUMENTATION_SKIP_SECTION # define STLSOFT_VER_H_STLSOFT_STRING_VIEW_MAJOR 2 # define STLSOFT_VER_H_STLSOFT_STRING_VIEW_MINOR 1 # define STLSOFT_VER_H_STLSOFT_STRING_VIEW_REVISION 3 # define STLSOFT_VER_H_STLSOFT_STRING_VIEW_EDIT 16 #endif /* !__STLSOFT_DOCUMENTATION_SKIP_SECTION */ /* ///////////////////////////////////////////////////////////////////////////// * Compatibility */ /* [Incompatibilies-start] __STLSOFT_COMPILER_IS_MWERKS: __MWERKS__<0x3000 [Incompatibilies-end] */ /* ///////////////////////////////////////////////////////////////////////////// * Includes */ #ifndef STLSOFT_INCL_H_STLSOFT # include "stlsoft.h" // Include the STLSoft root header #endif /* !STLSOFT_INCL_H_STLSOFT */ #ifndef STLSOFT_INCL_H_STLSOFT_AUTO_BUFFER # include "stlsoft_auto_buffer.h" // stlsoft::auto_buffer #endif /* !STLSOFT_INCL_H_STLSOFT_AUTO_BUFFER */ #ifndef STLSOFT_INCL_H_STLSOFT_NEW_ALLOCATOR # include "stlsoft_new_allocator.h" // stlsoft::new_allocator #endif /* !STLSOFT_INCL_H_STLSOFT_NEW_ALLOCATOR */ #ifndef STLSOFT_INCL_H_STLSOFT_CHAR_TRAITS # include "stlsoft_char_traits.h" // stlsoft::char_traits #endif /* !STLSOFT_INCL_H_STLSOFT_CHAR_TRAITS */ #ifndef STLSOFT_INCL_H_STLSOFT_ITERATOR # include "stlsoft_iterator.h" // stlsoft iterator bases #endif /* !STLSOFT_INCL_H_STLSOFT_ITERATOR */ /* ///////////////////////////////////////////////////////////////////////////// * Namespace */ #ifndef _STLSOFT_NO_NAMESPACE namespace stlsoft { #endif /* _STLSOFT_NO_NAMESPACE */ /* ////////////////////////////////////////////////////////////////////////// */ /// \weakgroup libraries STLSoft Libraries /// \brief The individual libraries /// \weakgroup libraries_string String Library /// \ingroup libraries /// \brief This library provides facilities for defining and manipulating strings /// \weakgroup stlsoft_string_library String Library (STLSoft) /// \ingroup STLSoft libraries_string /// \brief This library provides facilities for defining and manipulating strings /// @{ /* ///////////////////////////////////////////////////////////////////////////// * Classes */ // class basic_string_view /// A string class that holds no internal storage, and merely represents a window into other string storage /// /// \param C The character type /// \param T The traits type. On translators that support default template arguments this is defaulted to char_traits /// \param A The allocator type. On translators that support default template arguments this is defaulted to new_allocator. This is only used by the proxy generated by c_str() template< ss_typename_param_k C #ifdef __STLSOFT_CF_TEMPLATE_CLASS_DEFAULT_CLASS_ARGUMENT_SUPPORT , ss_typename_param_k T = char_traits , ss_typename_param_k A = new_allocator #else , ss_typename_param_k T /* = char_traits */ , ss_typename_param_k A /* = new_allocator */ #endif /* __STLSOFT_CF_TEMPLATE_CLASS_DEFAULT_CLASS_ARGUMENT_SUPPORT */ > class basic_string_view { public: /// The value type typedef C value_type; /// The traits type typedef T traits_type; /// The allocator type typedef A allocator_type; /// The current parameterisation of the type typedef basic_string_view class_type; /// The character type typedef value_type char_type; #if 0 /// The pointer type typedef value_type const *pointer; #endif /* 0 */ /// The non-mutable (const) pointer type typedef value_type const *const_pointer; #if 0 /// The reference type typedef value_type &reference; #endif /* 0 */ /// The non-mutable (const) reference type typedef value_type const &const_reference; /// The size type typedef ss_size_t size_type; /// The difference type typedef ss_ptrdiff_t difference_type; #if 0 /// The iterator type typedef #if !defined(__STLSOFT_COMPILER_IS_BORLAND) ss_typename_type_k #endif /* __STLSOFT_COMPILER_IS_BORLAND */ pointer_iterator < value_type , pointer , reference >::iterator_type iterator; #endif /* 0 */ /// The non-mutating (const) iterator type typedef #if !defined(__STLSOFT_COMPILER_IS_BORLAND) ss_typename_type_k #endif /* __STLSOFT_COMPILER_IS_BORLAND */ pointer_iterator < value_type const , const_pointer , const_reference >::iterator_type const_iterator; #if defined(__STLSOFT_CF_BIDIRECTIONAL_ITERATOR_SUPPORT) #if 0 /// The reverse iterator type typedef reverse_iterator_base < iterator , value_type , reference , pointer , difference_type > reverse_iterator; #endif /* 0 */ /// The non-mutating (const) reverse iterator type typedef const_reverse_iterator_base < const_iterator , value_type const , const_reference , const_pointer , difference_type > const_reverse_iterator; #endif /* __STLSOFT_CF_BIDIRECTIONAL_ITERATOR_SUPPORT */ /// \name Construction /// @{ public: /// Default constructor basic_string_view(); /// Copy constructor basic_string_view(class_type const &rhs); /// Construct from the given string at the specified position basic_string_view(class_type const &s, size_type pos); /// Construct with \c cch characters from the given string at the specified position basic_string_view(class_type const &s, size_type pos, size_type cch); /// Construct from a null-terminated character string basic_string_view(char_type const *s); // Not, not explicit! Sigh /// Construct with \c cch characters from the given character string basic_string_view(char_type const *s, size_type cch); /// Construct from the range [first:last) #if !defined(__STLSOFT_CF_MEMBER_TEMPLATE_RANGE_METHOD_SUPPORT) basic_string_view(char_type const *first, char_type const *last); #else template basic_string_view(RAI first, RAI last) : m_length(last - first) , m_base(first) , m_cstr(NULL) { stlsoft_assert(first <= last); stlsoft_assert(is_valid()); } #endif /* __STLSOFT_CF_MEMBER_TEMPLATE_RANGE_METHOD_SUPPORT */ #ifdef __STLSOFT_CF_STATIC_ARRAY_SIZE_DETERMINATION_SUPPORT /// Constructs from an array template ss_explicit_k basic_string_view(D (&d)[N]) : m_length(N) , m_base(&d[0]) , m_cstr(NULL) {} #endif /* __STLSOFT_CF_STATIC_ARRAY_SIZE_DETERMINATION_SUPPORT */ /// Destructor ~basic_string_view(); /// @} /// \name Operations /// @{ public: /// Swaps the contents between \c this and \c other void swap(class_type &other); /// Empties the string void clear(); /// @} /// \name Attributes /// @{ public: /// The number of elements in the string size_type size() const; /// The maximum number of elements that can be stored in the string static size_type max_size(); /// The number of elements in the string size_type length() const; /// The storage currently allocated by the string size_type capacity() const; /// Indicates whether the string is empty ss_bool_t empty() const; /// @} /// \name Comparison /// @{ public: /// Evaluates whether two strings are equal ss_bool_t equal(class_type const &rhs) const; /// Evaluates whether two strings are equal ss_bool_t equal(value_type const *rhs, size_type cchRhs) const; /// Compares \c this with the given string ss_sint_t compare(size_type pos, size_type cch, value_type const *s, size_type cchRhs) const; /// Compares \c this with the given string ss_sint_t compare(size_type pos, size_type cch, value_type const *s) const; /// Compares \c this with the given string ss_sint_t compare(value_type const *s) const; /// Compares \c this with the given string ss_sint_t compare(size_type pos, size_type cch, class_type const &rhs, size_type posRhs, size_type cchRhs) const; /// Compares \c this with the given string ss_sint_t compare(size_type pos, size_type cch, class_type const &rhs) const; /// Compares \c this with the given string ss_sint_t compare(class_type const &rhs) const; /// @} /// \name Accessors /// @{ public: #if 0 /// Returns mutable reference at the given index reference operator [](size_type index); #endif /* 0 */ /// Returns non-mutable (const) reference at the given index const_reference operator [](size_type index) const; /// Returns null-terminated non-mutable (const) pointer to string data value_type const *c_str() const; /// Returns non-mutable (const) pointer to string data value_type const *data() const; #if 0 /// Returns the first character in the string /// /// \note It is up to the user to ensure that the string is not empty reference front(); /// Returns the last character in the string /// /// \note It is up to the user to ensure that the string is not empty reference back(); #endif /* 0 */ /// Returns the first character in the string /// /// \note It is up to the user to ensure that the string is not empty const_reference front() const; /// Returns the last character in the string /// /// \note It is up to the user to ensure that the string is not empty const_reference back() const; /// Copies elements into the given destination size_type copy(value_type *dest, size_type cch, size_type pos = 0) const; /// @} /// \name Iteration /// @{ public: /// Begins the iteration /// /// \return A non-mutable (const) iterator representing the start of the sequence const_iterator begin() const; /// Ends the iteration /// /// \return A non-mutable (const) iterator representing the end of the sequence const_iterator end() const; #if 0 /// Begins the iteration /// /// \return An iterator representing the start of the sequence iterator begin(); /// Ends the iteration /// /// \return An iterator representing the end of the sequence iterator end(); #endif /* 0 */ #if defined(__STLSOFT_CF_BIDIRECTIONAL_ITERATOR_SUPPORT) /// Begins the reverse iteration /// /// \return A non-mutable (const) iterator representing the start of the reverse sequence const_reverse_iterator rbegin() const; /// Ends the reverse iteration /// /// \return A non-mutable (const) iterator representing the end of the reverse sequence const_reverse_iterator rend() const; #if 0 /// Begins the reverse iteration /// /// \return An iterator representing the start of the reverse sequence reverse_iterator rbegin(); /// Ends the reverse iteration /// /// \return An iterator representing the end of the reverse sequence reverse_iterator rend(); #endif /* 0 */ #endif /* __STLSOFT_CF_BIDIRECTIONAL_ITERATOR_SUPPORT */ /// @} /// \name Invariant #ifdef STLSOFT_UNITTEST public: #else private: #endif /* STLSOFT_UNITTEST */ ss_bool_t is_valid() const; /// \name Implementation /// @{ private: // Empty string static char_type const *empty_string_(); // Comparison static ss_sint_t compare_(char_type const *lhs, size_type lhs_len, char_type const *rhs, size_type rhs_len); /// @} /// \name Members /// @{ private: size_type m_length; char_type const *m_base; char_type *m_cstr; /// @} }; /* ///////////////////////////////////////////////////////////////////////////// * Operators */ #ifndef __STLSOFT_DOCUMENTATION_SKIP_SECTION // operator == template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline ss_bool_t operator ==(basic_string_view const &lhs, basic_string_view const &rhs) { return lhs.equal(rhs); } template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > #ifdef __STLSOFT_CF_TEMPLATE_OUTOFCLASSFN_QUALIFIED_TYPE_SUPPORT inline ss_bool_t operator ==(basic_string_view const &lhs, ss_typename_type_k basic_string_view::char_type const *rhs) #else inline ss_bool_t operator ==(basic_string_view const &lhs, C const *rhs) #endif /* __STLSOFT_CF_TEMPLATE_OUTOFCLASSFN_QUALIFIED_TYPE_SUPPORT */ { typedef ss_typename_type_k basic_string_view::size_type size_type; typedef ss_typename_type_k basic_string_view::traits_type traits_type; size_type rhs_len = (NULL == rhs) ? 0 : traits_type::length(rhs); return lhs.equal(rhs, rhs_len); } template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > #ifdef __STLSOFT_CF_TEMPLATE_OUTOFCLASSFN_QUALIFIED_TYPE_SUPPORT inline ss_bool_t operator ==(ss_typename_type_k basic_string_view::char_type const *lhs, basic_string_view const &rhs) #else inline ss_bool_t operator ==(C *lhs, basic_string_view const &rhs) #endif /* __STLSOFT_CF_TEMPLATE_OUTOFCLASSFN_QUALIFIED_TYPE_SUPPORT */ { typedef ss_typename_type_k basic_string_view::size_type size_type; typedef ss_typename_type_k basic_string_view::traits_type traits_type; size_type lhs_len = (NULL == lhs) ? 0 : traits_type::length(lhs); return rhs.equal(lhs, lhs_len); } // operator != template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline ss_bool_t operator !=(basic_string_view const &lhs, basic_string_view const &rhs) { return !lhs.equal(rhs); } template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > #ifdef __STLSOFT_CF_TEMPLATE_OUTOFCLASSFN_QUALIFIED_TYPE_SUPPORT inline ss_bool_t operator !=(basic_string_view const &lhs, ss_typename_type_k basic_string_view::char_type const *rhs) #else inline ss_bool_t operator !=(basic_string_view const &lhs, C const *rhs) #endif /* __STLSOFT_CF_TEMPLATE_OUTOFCLASSFN_QUALIFIED_TYPE_SUPPORT */ { typedef ss_typename_type_k basic_string_view::size_type size_type; typedef ss_typename_type_k basic_string_view::traits_type traits_type; size_type rhs_len = (NULL == rhs) ? 0 : traits_type::length(rhs); return !lhs.equal(rhs, rhs_len); } template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > #ifdef __STLSOFT_CF_TEMPLATE_OUTOFCLASSFN_QUALIFIED_TYPE_SUPPORT inline ss_bool_t operator !=(ss_typename_type_k basic_string_view::char_type const *lhs, basic_string_view const &rhs) #else inline ss_bool_t operator !=(C const *lhs, basic_string_view const &rhs) #endif /* __STLSOFT_CF_TEMPLATE_OUTOFCLASSFN_QUALIFIED_TYPE_SUPPORT */ { typedef ss_typename_type_k basic_string_view::size_type size_type; typedef ss_typename_type_k basic_string_view::traits_type traits_type; size_type lhs_len = (NULL == lhs) ? 0 : traits_type::length(lhs); return !rhs.equal(lhs, lhs_len); } // operator < template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline ss_bool_t operator <(basic_string_view const &lhs, basic_string_view const &rhs) { return lhs.compare(rhs) < 0; } template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > #ifdef __STLSOFT_CF_TEMPLATE_OUTOFCLASSFN_QUALIFIED_TYPE_SUPPORT inline ss_bool_t operator <(basic_string_view const &lhs, ss_typename_type_k basic_string_view::char_type const *rhs) #else inline ss_bool_t operator <(basic_string_view const &lhs, C const *rhs) #endif /* __STLSOFT_CF_TEMPLATE_OUTOFCLASSFN_QUALIFIED_TYPE_SUPPORT */ { return lhs.compare(rhs) < 0; } template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > #ifdef __STLSOFT_CF_TEMPLATE_OUTOFCLASSFN_QUALIFIED_TYPE_SUPPORT inline ss_bool_t operator <(ss_typename_type_k basic_string_view::char_type const *lhs, basic_string_view const &rhs) #else inline ss_bool_t operator <(C const *lhs, basic_string_view const &rhs) #endif /* __STLSOFT_CF_TEMPLATE_OUTOFCLASSFN_QUALIFIED_TYPE_SUPPORT */ { return rhs.compare(lhs) > 0; } // operator <= template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline ss_bool_t operator <=(basic_string_view const &lhs, basic_string_view const &rhs) { return lhs.compare(rhs) <= 0; } template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > #ifdef __STLSOFT_CF_TEMPLATE_OUTOFCLASSFN_QUALIFIED_TYPE_SUPPORT inline ss_bool_t operator <=(basic_string_view const &lhs, ss_typename_type_k basic_string_view::char_type const *rhs) #else inline ss_bool_t operator <=(basic_string_view const &lhs, C const *rhs) #endif /* __STLSOFT_CF_TEMPLATE_OUTOFCLASSFN_QUALIFIED_TYPE_SUPPORT */ { return lhs.compare(rhs) <= 0; } template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > #ifdef __STLSOFT_CF_TEMPLATE_OUTOFCLASSFN_QUALIFIED_TYPE_SUPPORT inline ss_bool_t operator <=(ss_typename_type_k basic_string_view::char_type const *lhs, basic_string_view const &rhs) #else inline ss_bool_t operator <=(C const *lhs, basic_string_view const &rhs) #endif /* __STLSOFT_CF_TEMPLATE_OUTOFCLASSFN_QUALIFIED_TYPE_SUPPORT */ { return rhs.compare(lhs) >= 0; } // operator > template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline ss_bool_t operator >(basic_string_view const &lhs, basic_string_view const &rhs) { return lhs.compare(rhs) > 0; } template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > #ifdef __STLSOFT_CF_TEMPLATE_OUTOFCLASSFN_QUALIFIED_TYPE_SUPPORT inline ss_bool_t operator >(basic_string_view const &lhs, ss_typename_type_k basic_string_view::char_type const *rhs) #else inline ss_bool_t operator >(basic_string_view const &lhs, C const *rhs) #endif /* __STLSOFT_CF_TEMPLATE_OUTOFCLASSFN_QUALIFIED_TYPE_SUPPORT */ { return lhs.compare(rhs) > 0; } template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > #ifdef __STLSOFT_CF_TEMPLATE_OUTOFCLASSFN_QUALIFIED_TYPE_SUPPORT inline ss_bool_t operator >(ss_typename_type_k basic_string_view::char_type const *lhs, basic_string_view const &rhs) #else inline ss_bool_t operator >(C const *lhs, basic_string_view const &rhs) #endif /* __STLSOFT_CF_TEMPLATE_OUTOFCLASSFN_QUALIFIED_TYPE_SUPPORT */ { return rhs.compare(lhs) < 0; } // operator >= template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline ss_bool_t operator >=(basic_string_view const &lhs, basic_string_view const &rhs) { return lhs.compare(rhs) >= 0; } template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > #ifdef __STLSOFT_CF_TEMPLATE_OUTOFCLASSFN_QUALIFIED_TYPE_SUPPORT inline ss_bool_t operator >=(basic_string_view const &lhs, ss_typename_type_k basic_string_view::char_type const *rhs) #else inline ss_bool_t operator >=(basic_string_view const &lhs, C const *rhs) #endif /* __STLSOFT_CF_TEMPLATE_OUTOFCLASSFN_QUALIFIED_TYPE_SUPPORT */ { return lhs.compare(rhs) >= 0; } template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > #ifdef __STLSOFT_CF_TEMPLATE_OUTOFCLASSFN_QUALIFIED_TYPE_SUPPORT inline ss_bool_t operator >=(ss_typename_type_k basic_string_view::char_type const *lhs, basic_string_view const &rhs) #else inline ss_bool_t operator >=(C const *lhs, basic_string_view const &rhs) #endif /* __STLSOFT_CF_TEMPLATE_OUTOFCLASSFN_QUALIFIED_TYPE_SUPPORT */ { return rhs.compare(lhs) <= 0; } #endif /* !__STLSOFT_DOCUMENTATION_SKIP_SECTION */ /* ///////////////////////////////////////////////////////////////////////////// * IOStream compatibility */ template< ss_typename_param_k S , ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline S &operator <<(S & s, basic_string_view const &str) { s.write(str.data(), str.length()); return s; } /* ///////////////////////////////////////////////////////////////////////////// * Unit-testing */ #ifdef STLSOFT_UNITTEST namespace unittest { namespace { ss_bool_t test_stlsoft_string_view(unittest_reporter *r) { ss_bool_t bSuccess = true; unittest_initialiser init(r, "STLSoft", "string_view", __FILE__); typedef stlsoft_ns_qual(basic_string_view)< char , char_traits , new_allocator > seg_string_t; char const s[] = "Hello Natty!"; if(!seg_string_t().empty()) { r->report("Default construction and/or != comparison failed", __LINE__); bSuccess = false; } if(seg_string_t() != seg_string_t()) { r->report("Default construction and/or != comparison failed", __LINE__); bSuccess = false; } seg_string_t ss(s, stlsoft_num_elements(s) - 1); seg_string_t ss1(&s[6], 6); seg_string_t ss2(&s[0], 5); if(ss1 <= ss2) { r->report("<= comparison failed", __LINE__); bSuccess = false; } if(ss2 > ss1) { r->report("> comparison failed", __LINE__); bSuccess = false; } if(0 != seg_string_t("abc", 3).compare("abc")) { r->report("compare(s) failed", __LINE__); bSuccess = false; } if(0 != seg_string_t("abcdef", 3).compare(0, 3, "abc")) { r->report("compare(p, cch, s) failed", __LINE__); bSuccess = false; } if(0 != seg_string_t("Well done Matty!", 16).compare(11, 5, ss, 7, 5)) { r->report("compare(p, cch, r, rp, rn) failed", __LINE__); bSuccess = false; } return bSuccess; } unittest_registrar unittest_stlsoft_string_view(test_stlsoft_string_view); } // anonymous namespace } // namespace unittest #endif /* STLSOFT_UNITTEST */ /* ///////////////////////////////////////////////////////////////////////////// * Implementation */ #ifndef __STLSOFT_DOCUMENTATION_SKIP_SECTION // Implementation template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline /* static */ ss_typename_type_k basic_string_view::char_type const *basic_string_view::empty_string_() { // This character array is initialised to 0, which conveniently happens to // be the empty string, by the module/application load, so it is // guaranteed to be valid, and there are no threading/race conditions static char_type s_empty[1]; stlsoft_assert(s_empty[0] == '\0'); // Paranoid check return s_empty; } template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline /* static */ ss_sint_t basic_string_view::compare_( ss_typename_type_k basic_string_view::value_type const *lhs , ss_typename_type_k basic_string_view::size_type lhs_len , ss_typename_type_k basic_string_view::value_type const *rhs , ss_typename_type_k basic_string_view::size_type rhs_len) { size_type cmp_len = (lhs_len < rhs_len) ? lhs_len : rhs_len; ss_int_t result = traits_type::compare(lhs, rhs, cmp_len); if(0 == result) { result = static_cast(lhs_len) - static_cast(rhs_len); } return result; } /// Invariant template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline ss_bool_t basic_string_view::is_valid() const { // NOTE: Must not call any methods or ctors in this function!! if( NULL == m_base && NULL != m_cstr) { return false; } return true; } // Construction template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline basic_string_view::basic_string_view() : m_length(0) , m_base(NULL) , m_cstr(NULL) { stlsoft_assert(is_valid()); } template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline basic_string_view::basic_string_view(basic_string_view const &rhs) : m_length(rhs.m_length) , m_base(rhs.m_base) , m_cstr(NULL) { stlsoft_assert(is_valid()); } template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline basic_string_view::basic_string_view(basic_string_view const &rhs, ss_typename_type_k basic_string_view::size_type pos) : m_length(rhs.m_length - pos) , m_base(&rhs[pos]) // Use this so we get the debug-time invariant checking on the validity of pos , m_cstr(NULL) { stlsoft_assert(pos <= rhs.m_length); stlsoft_assert(is_valid()); } template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline basic_string_view::basic_string_view( basic_string_view const &rhs , ss_typename_type_k basic_string_view::size_type pos , ss_typename_type_k basic_string_view::size_type cch) : m_length(cch) , m_base(&rhs[pos]) // Use this so we get the debug-time invariant checking on the validity of pos , m_cstr(NULL) { stlsoft_assert(is_valid()); } template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline basic_string_view::basic_string_view(ss_typename_type_k basic_string_view::char_type const *s) : m_length(T::length(s)) , m_base(s) , m_cstr(NULL) { stlsoft_assert(is_valid()); } template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline basic_string_view::basic_string_view( ss_typename_type_k basic_string_view::char_type const *s , ss_typename_type_k basic_string_view::size_type cch) : m_length(cch) , m_base(s) , m_cstr(NULL) { stlsoft_assert(is_valid()); } #if !defined(__STLSOFT_CF_MEMBER_TEMPLATE_RANGE_METHOD_SUPPORT) template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline basic_string_view::basic_string_view( ss_typename_type_k basic_string_view::char_type const *first , ss_typename_type_k basic_string_view::char_type const *last) : m_length(last - first) , m_base(first) , m_cstr(NULL) { stlsoft_assert(first <= last); stlsoft_assert(is_valid()); } #endif /* __STLSOFT_CF_MEMBER_TEMPLATE_RANGE_METHOD_SUPPORT */ template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline basic_string_view::~basic_string_view() { stlsoft_assert(is_valid()); allocator_type ator; ator.deallocate(m_cstr); } // Operations template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline void basic_string_view::swap(ss_typename_type_k basic_string_view::class_type &rhs) { stlsoft_assert(is_valid()); std::swap(m_length, rhs.m_length); std::swap(m_base, rhs.m_base); std::swap(m_cstr, rhs.m_cstr); stlsoft_assert(is_valid()); } template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline void basic_string_view::clear() { stlsoft_assert(is_valid()); m_length = 0; m_base = NULL; allocator_type ator; ator.deallocate(m_cstr); stlsoft_assert(is_valid()); } // Attributes template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline ss_typename_type_k basic_string_view::size_type basic_string_view::size() const { stlsoft_assert(is_valid()); return m_length; } template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline /* static */ ss_typename_type_k basic_string_view::size_type basic_string_view::max_size() { return static_cast(-1) / sizeof(char_type); } // size_type max_size() const; template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline ss_typename_type_k basic_string_view::size_type basic_string_view::length() const { stlsoft_assert(is_valid()); return m_length; } template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline ss_typename_type_k basic_string_view::size_type basic_string_view::capacity() const { stlsoft_assert(is_valid()); return m_length; } template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline ss_bool_t basic_string_view::empty() const { stlsoft_assert(is_valid()); return 0 == size(); } // Comparison template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline ss_bool_t basic_string_view::equal(ss_typename_type_k basic_string_view::class_type const &rhs) const { stlsoft_assert(is_valid()); return (m_length == rhs.m_length) && ((m_base == rhs.m_base) || 0 == compare(rhs)); } template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline ss_bool_t basic_string_view::equal(ss_typename_type_k basic_string_view::value_type const *rhs, ss_typename_type_k basic_string_view::size_type cchRhs) const { stlsoft_assert(is_valid()); return (m_length == cchRhs) && ((m_base == rhs) || 0 == compare_(m_base, m_length, rhs, cchRhs)); } template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline ss_sint_t basic_string_view::compare( ss_typename_type_k basic_string_view::size_type pos , ss_typename_type_k basic_string_view::size_type cch , ss_typename_type_k basic_string_view::value_type const *rhs , ss_typename_type_k basic_string_view::size_type cchRhs) const { stlsoft_assert(is_valid()); size_type lhs_len = length(); if(!(pos < lhs_len)) { pos = lhs_len; } else { lhs_len -= pos; } if(cch < lhs_len) { lhs_len = cch; } size_type rhs_len = (NULL == rhs) ? 0 : traits_type::length(rhs); if(cchRhs < rhs_len) { rhs_len = cchRhs; } stlsoft_assert(is_valid()); return compare_(m_base + pos, lhs_len, rhs, rhs_len); } template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline ss_sint_t basic_string_view::compare( ss_typename_type_k basic_string_view::size_type pos , ss_typename_type_k basic_string_view::size_type cch , ss_typename_type_k basic_string_view::value_type const *rhs) const { stlsoft_assert(is_valid()); size_type lhs_len = length(); if(!(pos < lhs_len)) { pos = lhs_len; } else { lhs_len -= pos; } if(cch < lhs_len) { lhs_len = cch; } size_type rhs_len = (NULL == rhs) ? 0 : traits_type::length(rhs); stlsoft_assert(is_valid()); return compare_(m_base + pos, lhs_len, rhs, rhs_len); } template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline ss_sint_t basic_string_view::compare(ss_typename_type_k basic_string_view::value_type const *rhs) const { stlsoft_assert(is_valid()); size_type lhs_len = length(); size_type rhs_len = (NULL == rhs) ? 0 : traits_type::length(rhs); return compare_(m_base, lhs_len, rhs, rhs_len); } template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline ss_sint_t basic_string_view::compare( ss_typename_type_k basic_string_view::size_type pos , ss_typename_type_k basic_string_view::size_type cch , ss_typename_type_k basic_string_view::class_type const &rhs , ss_typename_type_k basic_string_view::size_type posRhs , ss_typename_type_k basic_string_view::size_type cchRhs) const { stlsoft_assert(is_valid()); size_type lhs_len = length(); if(!(pos < lhs_len)) { pos = lhs_len; } else { lhs_len -= pos; } if(cch < lhs_len) { lhs_len = cch; } size_type rhs_len = rhs.length(); if(!(posRhs < rhs_len)) { posRhs = rhs_len; } else { rhs_len -= posRhs; } if(cchRhs < rhs_len) { rhs_len = cchRhs; } stlsoft_assert(is_valid()); return compare_(m_base + pos, lhs_len, rhs.m_base + posRhs, rhs_len); } template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline ss_sint_t basic_string_view::compare( ss_typename_type_k basic_string_view::size_type pos , ss_typename_type_k basic_string_view::size_type cch , ss_typename_type_k basic_string_view::class_type const &rhs) const { stlsoft_assert(is_valid()); size_type lhs_len = length(); if(!(pos < lhs_len)) { pos = lhs_len; } else { lhs_len -= pos; } if(cch < lhs_len) { lhs_len = cch; } size_type rhs_len = rhs.length(); stlsoft_assert(is_valid()); return compare_(m_base + pos, lhs_len, rhs.m_base, rhs_len); } template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline ss_sint_t basic_string_view::compare(ss_typename_type_k basic_string_view::class_type const &rhs) const { stlsoft_assert(is_valid()); size_type lhs_len = length(); size_type rhs_len = rhs.length(); stlsoft_assert(is_valid()); return compare_(m_base, lhs_len, rhs.m_base, rhs_len); } // Accessors #if 0 template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline ss_typename_type_k basic_string_view::reference basic_string_view::operator [](ss_typename_type_k basic_string_view::size_type index) { stlsoft_assert(is_valid()); return m_base[index]; } #endif /* 0 */ template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline ss_typename_type_k basic_string_view::const_reference basic_string_view::operator [](ss_typename_type_k basic_string_view::size_type index) const { stlsoft_assert(is_valid()); return m_base[index]; } template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline ss_typename_type_k basic_string_view::value_type const *basic_string_view::c_str() const { stlsoft_assert(is_valid()); if(NULL != m_cstr) { return m_cstr; } else { if(NULL == m_base) { return empty_string_(); } else { // Must allocate the m_cstr member allocator_type ator; char_type *s = ator.allocate(1 + length()); traits_type::copy(s, m_base, m_length); s[m_length] = '\0'; remove_const(m_cstr) = s; stlsoft_assert(is_valid()); return m_cstr; } } } template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline ss_typename_type_k basic_string_view::value_type const *basic_string_view::data() const { stlsoft_assert(is_valid()); return (NULL == m_base) ? empty_string_() : m_base; } #if 0 template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline ss_typename_type_k basic_string_view::reference basic_string_view::front() { stlsoft_assert(is_valid()); return (*this)[0]; } template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline ss_typename_type_k basic_string_view::reference basic_string_view::back() { stlsoft_assert(is_valid()); return (*this)[length() - 1]; } #endif /* 0 */ template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline ss_typename_type_k basic_string_view::const_reference basic_string_view::front() const { stlsoft_assert(is_valid()); return (*this)[0]; } template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline ss_typename_type_k basic_string_view::const_reference basic_string_view::back() const { stlsoft_assert(is_valid()); return (*this)[length() - 1]; } template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline ss_typename_type_k basic_string_view::size_type basic_string_view::copy( ss_typename_type_k basic_string_view::value_type *dest , ss_typename_type_k basic_string_view::size_type cch , ss_typename_type_k basic_string_view::size_type pos /* = 0 */) const { stlsoft_assert(is_valid()); size_type len = length(); if(pos < len) { if(len < pos + cch) { cch = len - pos; } traits_type::copy(dest, data() + pos, cch); } else { cch = 0; } stlsoft_assert(is_valid()); return cch; } // Iteration template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline ss_typename_type_k basic_string_view::const_iterator basic_string_view::begin() const { stlsoft_assert(is_valid()); return m_base; } template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline ss_typename_type_k basic_string_view::const_iterator basic_string_view::end() const { stlsoft_assert(is_valid()); return begin() + m_length; } #if 0 template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline ss_typename_type_k basic_string_view::iterator basic_string_view::begin() { stlsoft_assert(is_valid()); return m_base; } template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline ss_typename_type_k basic_string_view::iterator basic_string_view::end() { stlsoft_assert(is_valid()); return begin() + m_length; } #endif /* 0 */ #if defined(__STLSOFT_CF_BIDIRECTIONAL_ITERATOR_SUPPORT) template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline ss_typename_type_k basic_string_view::const_reverse_iterator basic_string_view::rbegin() const { stlsoft_assert(is_valid()); return const_reverse_iterator(end()); } template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline ss_typename_type_k basic_string_view::const_reverse_iterator basic_string_view::rend() const { stlsoft_assert(is_valid()); return const_reverse_iterator(begin()); } #if 0 template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline ss_typename_type_k basic_string_view::reverse_iterator basic_string_view::rbegin() { stlsoft_assert(is_valid()); return reverse_iterator(end()); } template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline ss_typename_type_k basic_string_view::reverse_iterator basic_string_view::rend() { stlsoft_assert(is_valid()); return reverse_iterator(begin()); } #endif /* 0 */ #endif /* __STLSOFT_CF_BIDIRECTIONAL_ITERATOR_SUPPORT */ /* ///////////////////////////////////////////////////////////////////////////// * String access shims */ #if 0 /* c_str_ptr_null */ /// \brief Returns the corresponding C-string pointer of \c s, or a null pointer template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline C const *c_str_ptr_null(basic_string_view const &s) { return (s.length() == 0) ? 0 : s.c_str(); } /* c_str_ptr */ /// \brief Returns the corresponding C-string pointer of \c s template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline C const *c_str_ptr(basic_string_view const &s) { return s.c_str(); } /// \brief Returns the corresponding C-string pointer of \c s template< ss_typename_param_k T , ss_typename_param_k A > inline ss_char_a_t const *c_str_ptr_a(basic_string_view const &s) { return s.c_str(); } /// \brief Returns the corresponding C-string pointer of \c s template< ss_typename_param_k T , ss_typename_param_k A > inline ss_char_w_t const *c_str_ptr_w(basic_string_view const &s) { return s.c_str(); } /* c_str_ptr_len */ /// \brief Returns the length (in characters) of \c s, not including the null-terminating character template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline ss_size_t c_str_len(basic_string_view const &s) { return s.length(); } /* c_str_ptr_size */ /// \brief Returns the size (in bytes) of the contents of \c s, not including the null-terminating character template< ss_typename_param_k C , ss_typename_param_k T , ss_typename_param_k A > inline ss_size_t c_str_size(basic_string_view const &s) { return c_str_len(s) * sizeof(C); } #endif /* 0 */ #endif /* !__STLSOFT_DOCUMENTATION_SKIP_SECTION */ /* ////////////////////////////////////////////////////////////////////////// */ /// @} // end of group stlsoft_string_library /* ////////////////////////////////////////////////////////////////////////// */ #ifndef _STLSOFT_NO_NAMESPACE } // namespace stlsoft #endif /* _STLSOFT_NO_NAMESPACE */ /* ////////////////////////////////////////////////////////////////////////// */ #endif /* !STLSOFT_INCL_H_STLSOFT_STRING_VIEW */ /* ////////////////////////////////////////////////////////////////////////// */