String.h

Go to the documentation of this file.

//     ____   ______ __
//    / __ \ / ____// /
//   / /_/ // /    / /
//  / ____// /___ / /___   PixInsight Class Library
// /_/     \____//_____/   PCL 2.6.5
// ----------------------------------------------------------------------------
// pcl/String.h - Released 2024-01-13T15:47:58Z
// ----------------------------------------------------------------------------
// This file is part of the PixInsight Class Library (PCL).
// PCL is a multiplatform C++ framework for development of PixInsight modules.
//
// Copyright (c) 2003-2024 Pleiades Astrophoto S.L. All Rights Reserved.
//
// Redistribution and use in both source and binary forms, with or without
// modification, is permitted provided that the following conditions are met:
//
// 1. All redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//
// 2. All 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.
//
// 3. Neither the names "PixInsight" and "Pleiades Astrophoto", nor the names
//    of their contributors, may be used to endorse or promote products derived
//    from this software without specific prior written permission. For written
//    permission, please contact info@pixinsight.com.
//
// 4. All products derived from this software, in any form whatsoever, must
//    reproduce the following acknowledgment in the end-user documentation
//    and/or other materials provided with the product:
//
//    "This product is based on software from the PixInsight project, developed
//    by Pleiades Astrophoto and its contributors (https://pixinsight.com/)."
//
//    Alternatively, if that is where third-party acknowledgments normally
//    appear, this acknowledgment must be reproduced in the product itself.
//
// THIS SOFTWARE IS PROVIDED BY PLEIADES ASTROPHOTO AND ITS 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 PLEIADES ASTROPHOTO OR ITS
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, BUSINESS
// INTERRUPTION; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; AND LOSS OF USE,
// DATA OR PROFITS) 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.
// ----------------------------------------------------------------------------
 
#ifndef __PCL_String_h
#define __PCL_String_h
 
 
#include <pcl/Defs.h>
#include <pcl/Diagnostics.h>
 
#include <pcl/Allocator.h>
#include <pcl/Atomic.h>
#include <pcl/ByteArray.h>
#include <pcl/CharTraits.h>
#include <pcl/Container.h>
#include <pcl/Flags.h>
#include <pcl/Iterator.h>
#include <pcl/Math.h>
#include <pcl/ReferenceCounter.h>
#include <pcl/Sort.h>
#include <pcl/Utility.h>
 
#include <stdarg.h>
 
#ifdef __PCL_ALIGNED_STRING_ALLOCATION
#  include <pcl/AlignedAllocator.h>
#  define PCL_STRING_ALLOCATOR   AlignedAllocator
#else
#  include <pcl/StandardAllocator.h>
#  define PCL_STRING_ALLOCATOR   StandardAllocator
#endif
 
#ifndef __PCL_NO_STRING_COMPLEX
#  include <pcl/Complex.h>
#endif
 
#ifndef __PCL_NO_STRING_OSTREAM
#  ifndef _MSC_VER
#    define _GLIBCXX_USE_WCHAR_T  1
#  endif
#  include <ostream>
#endif
 
#ifdef __PCL_QT_INTERFACE
#  include <QtCore/QByteArray>
#  include <QtCore/QDateTime>
#  include <QtCore/QString>
#  define PCL_GET_CHARPTR_FROM_QSTRING( qs )       (qs.toLatin1().data())
#  define PCL_GET_CHAR16PTR_FROM_QSTRING( qs )     ((char16_type*)( qs.utf16() ))
#  define PCL_GET_CHARPTR_FROM_QSTRINGVIEW( qv )   ((const char*)qv.data())
#  define PCL_GET_CHAR16PTR_FROM_QSTRINGVIEW( qv ) ((const char16_type*)qv.data())
#  define PCL_GET_QSTRING_FROM_CHAR16PTR( s )      (QString::fromUtf16( (const char16_t*)(s) ))
#  define PCL_GET_CHARPTR_FROM_QBYTEARRAY( qb )    (qb.data())
#  define PCL_QDATE_FMT_STR                        "yyyy/MM/dd"
#  define PCL_QDATETIME_FMT_STR                    "yyyy/MM/dd hh:mm:ss"
#endif
 
namespace pcl
{
 
#ifndef __PCL_NO_STRING_VECTOR
   template <typename T> class PCL_CLASS GenericVector;
#endif
 
// ----------------------------------------------------------------------------
 
namespace RandomizationOption
{
   enum mask_type
   {
      Lowercase = 0x00000001,  // Generate random lowercase alphabetic characters: a..z
      Uppercase = 0x00000002,  // Generate random uppercase alphabetic characters: A..Z
      Alpha     = Lowercase|Uppercase,  // Generate random alphabetic characters: a..zA..Z
      Digits    = 0x00000004,  // Generate random decimal digits: 0..9
      Symbols   = 0x00000008,  // Generate random symbol characters: .#/[]() etc
      HexDigits = 0x00000010,  // Generate hexadecimal digits: 0..9a..f or 0..9A..F
      BinDigits = 0x00000020,  // Generate binary digits: 0 and 1
      FullRange = 0x80000000,  // Generate random characters in the whole range of code points except zero
      Default = Alpha|Digits
   };
};
 
using RandomizationOptions = Flags<RandomizationOption::mask_type>;
 
// ----------------------------------------------------------------------------
 
struct PCL_CLASS SexagesimalConversionOptions
{
   unsigned items     : 2;
 
   unsigned precision : 4;
 
   bool     sign      : 1;
 
   unsigned width     : 4;
 
   char     separator;
 
   char     padding;
 
   constexpr SexagesimalConversionOptions( unsigned items_     = 3,
                                           unsigned precision_ = 2,
                                           bool     sign_      = false,
                                           unsigned width_     = 0,
                                           char     separator_ = ':',
                                           char     padding_   = ' ' )
      : items( items_ )
      , precision( precision_ )
      , sign( sign_ )
      , width( width_ )
      , separator( separator_ )
      , padding( padding_ )
   {
   }
 
   SexagesimalConversionOptions( const SexagesimalConversionOptions& ) = default;
 
   SexagesimalConversionOptions& operator =( const SexagesimalConversionOptions& ) = default;
};
 
// ----------------------------------------------------------------------------
 
struct PCL_CLASS AngleConversionOptions : public SexagesimalConversionOptions
{
   constexpr AngleConversionOptions( unsigned precision = 2, unsigned width = 3, char padding = ' ' )
      : SexagesimalConversionOptions( 3/*items*/, precision, false/*sign*/, width, ' '/*separator*/, padding )
   {}
};
 
// ----------------------------------------------------------------------------
 
struct PCL_CLASS LongitudeConversionOptions : public SexagesimalConversionOptions
{
   constexpr LongitudeConversionOptions( unsigned precision = 2, unsigned width = 4, char padding = ' ' )
      : SexagesimalConversionOptions( 3/*items*/, precision, true/*sign*/, width, ' '/*separator*/, padding )
   {}
};
 
// ----------------------------------------------------------------------------
 
struct PCL_CLASS RAConversionOptions : public SexagesimalConversionOptions
{
   constexpr RAConversionOptions( unsigned precision = 3, unsigned width = 2, char padding = ' ' )
      : SexagesimalConversionOptions( 3/*items*/, precision, false/*sign*/, width, ' '/*separator*/, padding )
   {}
};
 
// ----------------------------------------------------------------------------
 
struct PCL_CLASS LatitudeConversionOptions : public SexagesimalConversionOptions
{
   constexpr LatitudeConversionOptions( unsigned precision = 2, unsigned width = 3, char padding = ' ' )
      : SexagesimalConversionOptions( 3/*items*/, precision, true/*sign*/, width, ' '/*separator*/, padding )
   {}
};
 
// ----------------------------------------------------------------------------
 
struct PCL_CLASS DecConversionOptions : public LatitudeConversionOptions
{
   constexpr DecConversionOptions( unsigned precision = 2, unsigned width = 3, char padding = ' ' )
      : LatitudeConversionOptions( precision, width, padding )
   {}
};
 
// ----------------------------------------------------------------------------
 
struct PCL_CLASS ISO8601ConversionOptions
{
   unsigned timeItems : 2;
 
   unsigned precision : 4;
 
   bool     timeZone  : 1;
 
   bool     zuluTime  : 1;
 
   constexpr ISO8601ConversionOptions( unsigned timeItems_ = 3,
                                       unsigned precision_ = 3,
                                       bool     timeZone_  = true,
                                       bool     zuluTime_  = true )
      : timeItems( timeItems_ )
      , precision( precision_ )
      , timeZone( timeZone_ )
      , zuluTime( zuluTime_ )
   {
   }
 
   ISO8601ConversionOptions( const ISO8601ConversionOptions& ) = default;
 
   ISO8601ConversionOptions& operator =( const ISO8601ConversionOptions& ) = default;
};
 
struct PCL_CLASS ISO8601ConversionOptionsNoTimeZone : public ISO8601ConversionOptions
{
   constexpr ISO8601ConversionOptionsNoTimeZone( unsigned timeItems_ = 3,
                                                 unsigned precision_ = 3 )
      : ISO8601ConversionOptions( timeItems_, precision_, false/*timeZone*/, false/*zuluTime*/ )
   {
   }
};
 
// ----------------------------------------------------------------------------
 
template <class T, class R, class A = PCL_STRING_ALLOCATOR>
class PCL_CLASS GenericString : public DirectContainer<T>
{
public:
 
   using char_type = T;
 
   using char_traits = R;
 
   using block_allocator = A;
 
   using allocator = pcl::Allocator<T,A>;
 
   using c_string = T*;
 
   using const_c_string = const T*;
 
   using iterator = T*;
 
   using const_iterator = const T*;
 
   using reverse_iterator = ReverseRandomAccessIterator<iterator, T>;
 
   using const_reverse_iterator = ReverseRandomAccessIterator<const_iterator, const T>;
 
   // -------------------------------------------------------------------------
 
   static const size_type notFound = ~size_type( 0 );
 
   static const size_type maxPos = ~size_type( 0 );
 
   // -------------------------------------------------------------------------
 
   GenericString()
   {
      m_data = Data::New();
   }
 
   GenericString( const GenericString& s )
      : m_data( s.m_data )
   {
      m_data->Attach();
   }
 
   GenericString( GenericString&& s )
      : m_data( s.m_data )
   {
      s.m_data = nullptr;
   }
 
   GenericString( const_c_string t )
   {
      size_type len = R::Length( t );
      if ( len > 0 )
      {
         m_data = Data::New( len );
         R::Copy( m_data->string, t, len );
      }
      else
         m_data = Data::New();
   }
 
   GenericString( const_iterator i, const_iterator j )
   {
      if ( i < j )
      {
         size_type len = j - i;
         m_data = Data::New( len );
         R::Copy( m_data->string, i, len );
      }
      else
         m_data = Data::New();
   }
 
   GenericString( std::initializer_list<char_type> l )
      : GenericString( l.begin(), l.end() )
   {
   }
 
   GenericString( const_c_string t, size_type i, size_type n )
   {
      size_type len = R::Length( t );
      if ( i < len && (n = pcl::Min( n, len-i )) > 0 )
      {
         m_data = Data::New( n );
         R::Copy( m_data->string, t+i, n );
      }
      else
         m_data = Data::New();
   }
 
   GenericString( char_type c, size_type n = 1 )
   {
      if ( n > 0 )
      {
         m_data = Data::New( n );
         R::Fill( m_data->string, c, n );
      }
      else
         m_data = Data::New();
   }
 
   ~GenericString()
   {
      if ( m_data != nullptr )
      {
         DetachFromData();
         m_data = nullptr;
      }
   }
 
   bool IsUnique() const noexcept
   {
      return m_data->IsUnique();
   }
 
   bool IsAliasOf( const GenericString& s ) const noexcept
   {
      return m_data == s.m_data;
   }
 
   void EnsureUnique()
   {
      if ( !IsUnique() )
      {
         size_type len = Length();
         Data* newData = Data::New( len );
         if ( len > 0 )
            R::Copy( newData->string, m_data->string, len );
         DetachFromData();
         m_data = newData;
      }
   }
 
   static size_type BytesPerChar() noexcept
   {
      return R::BytesPerChar();
   }
 
   size_type Size() const noexcept
   {
      return Length()*BytesPerChar();
   }
 
   size_type Length() const noexcept
   {
      return m_data->end - m_data->string;
   }
 
   size_type Capacity() const noexcept
   {
      return m_data->capacity - m_data->string;
   }
 
   size_type Available() const noexcept
   {
      return m_data->capacity - m_data->end;
   }
 
   bool IsValid() const noexcept
   {
      return m_data != nullptr;
   }
 
   bool IsEmpty() const noexcept
   {
      return m_data->string == m_data->end;
   }
 
   size_type LowerBound() const noexcept
   {
      return 0;
   }
 
   size_type UpperBound() const noexcept
   {
      PCL_PRECONDITION( !IsEmpty() )
      return Length()-1;
   }
 
   const allocator& Allocator() const noexcept
   {
      return m_data->alloc;
   }
 
   void SetAllocator( const allocator& a )
   {
      EnsureUnique();
      m_data->alloc = a;
   }
 
   iterator At( size_type i )
   {
      PCL_PRECONDITION( i < Length() )
      EnsureUnique();
      return m_data->string + i;
   }
 
   const_iterator At( size_type i ) const noexcept
   {
      PCL_PRECONDITION( i < Length() )
      return m_data->string + i;
   }
 
   char_type& operator []( size_type i )
   {
      return *At( i );
   }
 
   char_type operator []( size_type i ) const noexcept
   {
      return *At( i );
   }
 
   char_type& operator *()
   {
      EnsureUnique();
      return *m_data->string;
   }
 
   char_type operator *() const noexcept
   {
      return *m_data->string;
   }
 
   iterator Begin()
   {
      EnsureUnique();
      return m_data->string;
   }
 
   const_iterator Begin() const noexcept
   {
      return m_data->string;
   }
 
   iterator End()
   {
      EnsureUnique();
      return m_data->end;
   }
 
   const_iterator End() const noexcept
   {
      return m_data->end;
   }
 
   reverse_iterator ReverseBegin()
   {
      EnsureUnique();
      return (m_data->string < m_data->end) ? m_data->end-1 : nullptr;
   }
 
   const_reverse_iterator ReverseBegin() const noexcept
   {
      return (m_data->string < m_data->end) ? m_data->end-1 : nullptr;
   }
 
   reverse_iterator ReverseEnd()
   {
      EnsureUnique();
      return (m_data->string < m_data->end) ? m_data->string-1 : nullptr;
   }
 
   const_reverse_iterator ReverseEnd() const noexcept
   {
      return (m_data->string < m_data->end) ? m_data->string-1 : nullptr;
   }
 
   size_type IndexAt( const_iterator i ) const noexcept
   {
      PCL_PRECONDITION( i >= m_data->string )
      return i - m_data->string;
   }
 
#ifndef __PCL_NO_STL_COMPATIBLE_ITERATORS
 
   iterator begin()
   {
      return Begin();
   }
 
   const_iterator begin() const noexcept
   {
      return Begin();
   }
 
   iterator end()
   {
      return End();
   }
 
   const_iterator end() const noexcept
   {
      return End();
   }
#endif   // !__PCL_NO_STL_COMPATIBLE_ITERATORS
 
   const_c_string c_str() const noexcept
   {
      static const char_type theNullChar = char_traits::Null();
      return IsEmpty() ? &theNullChar : Begin();
   }
 
   GenericString& operator =( const GenericString& s )
   {
      Assign( s );
      return *this;
   }
 
   void Assign( const GenericString& s )
   {
      s.m_data->Attach();
      DetachFromData();
      m_data = s.m_data;
   }
 
   GenericString& operator =( GenericString&& s )
   {
      Transfer( s );
      return *this;
   }
 
   void Transfer( GenericString& s )
   {
      DetachFromData();
      m_data = s.m_data;
      s.m_data = nullptr;
   }
 
   void Transfer( GenericString&& s )
   {
      DetachFromData();
      m_data = s.m_data;
      s.m_data = nullptr;
   }
 
   GenericString& operator =( const_c_string t )
   {
      Assign( t );
      return *this;
   }
 
   GenericString& operator =( char_type c )
   {
      Assign( c, 1 );
      return *this;
   }
 
   void Assign( const GenericString& s, size_type i, size_type n )
   {
      Transfer( s.Substring( i, n ) );
   }
 
   void Assign( const_c_string t )
   {
      size_type len = R::Length( t );
      if ( len > 0 )
      {
         MaybeReallocate( len );
         R::Copy( m_data->string, t, len );
      }
      else
         Clear();
   }
 
   void Assign( const_iterator i, const_iterator j )
   {
      if ( i < j )
      {
         size_type len = j - i;
         MaybeReallocate( len );
         R::Copy( m_data->string, i, len );
      }
      else
         Clear();
   }
 
   void Assign( std::initializer_list<char_type> l )
   {
      Assign( l.begin(), l.end() );
   }
 
   void Assign( const_c_string t, size_type i, size_type n )
   {
      size_type len = R::Length( t );
      if ( i < len && (n = pcl::Min( n, len-i )) > 0 )
      {
         MaybeReallocate( n );
         R::Copy( m_data->string, t+i, n );
      }
      else
         Clear();
   }
 
   void Assign( char_type c, size_type n = 1 )
   {
      if ( !R::IsNull( c ) && n > 0 )
      {
         MaybeReallocate( n );
         R::Fill( m_data->string, c, n );
      }
      else
         Clear();
   }
 
   void Swap( GenericString& s ) noexcept
   {
      pcl::Swap( m_data, s.m_data );
   }
 
   void Fill( char_type c )
   {
      size_type len = Length();
      if ( len > 0 )
      {
         if ( !IsUnique() )
         {
            Data* newData = Data::New( len );
            DetachFromData();
            m_data = newData;
         }
         R::Fill( m_data->string, c, len );
      }
   }
 
   void Fill( char_type c, size_type i, size_type n = maxPos )
   {
      size_type len = Length();
      if ( i < len )
      {
         n = pcl::Min( n, len-i );
         if ( n < len )
            EnsureUnique();
         else if ( !IsUnique() )
         {
            Data* newData = Data::New( len );
            DetachFromData();
            m_data = newData;
         }
         R::Fill( m_data->string+i, c, n );
      }
   }
 
   void SecureFill( char c = '\0' ) noexcept
   {
      volatile char* s = reinterpret_cast<volatile char*>( m_data->string );
      for ( size_type n = Capacity()*sizeof( char_type ); n > 0; --n )
         *s++ = c;
   }
 
   void Reserve( size_type n )
   {
      if ( n > 0 )
         if ( IsUnique() )
         {
            if ( Capacity() < n+1 )
            {
               iterator old = m_data->string;
               size_type len = Length();
               m_data->Reserve( len, n );
               if ( old != nullptr )
               {
                  if ( len > 0 )
                     R::Copy( m_data->string, old, len );
                  m_data->alloc.Deallocate( old );
               }
            }
         }
         else
         {
            size_type len = Length();
            Data* newData = Data::New(); // ### FIXME: unlikely, but this is a potential leak
            newData->Reserve( len, pcl::Max( len, n ) );
            if ( len > 0 )
               R::Copy( newData->string, m_data->string, len );
            DetachFromData();
            m_data = newData;
         }
   }
 
   void SetLength( size_type n )
   {
      if ( n != Length() )
      {
         if ( n > 0 )
         {
            if ( !IsUnique() || m_data->ShouldReallocate( n ) )
            {
               Data* newData = Data::New( n );
               size_type m = Capacity();
               if ( m > 0 )
                  R::Copy( newData->string, m_data->string, pcl::Min( n, m ) );
               DetachFromData();
               m_data = newData;
            }
            else
               m_data->SetLength( n );
         }
         else
            Clear();
      }
      else
         EnsureUnique();
   }
 
   GenericString SetToLength( size_type n ) const
   {
      // NB: This can be done more efficiently if this string is unique.
      GenericString s( *this );
      s.SetLength( n );
      return s;
   }
 
   void ResizeToNullTerminated()
   {
      SetLength( R::Length( m_data->string ) );
   }
 
   GenericString ResizedToNullTerminated() const
   {
      GenericString s( *this );
      s.ResizeToNullTerminated();
      return s;
   }
 
   void Squeeze()
   {
      if ( Available() > 0 )
      {
         size_type len = Length();
         if ( len > 0 )
         {
            if ( IsUnique() )
            {
               iterator old = m_data->string;
               m_data->Allocate( len, 0 );
               R::Copy( m_data->string, old, len );
               m_data->alloc.Deallocate( old );
            }
            else
            {
               Data* newData = Data::New( len, 0 );
               R::Copy( newData->string, m_data->string, len );
               DetachFromData();
               m_data = newData;
            }
         }
         else
            Clear();
      }
   }
 
   GenericString Squeezed() const
   {
      // NB: This can be done more efficiently if this string is unique.
      GenericString s( *this );
      s.Squeeze();
      return s;
   }
 
   c_string Release()
   {
      EnsureUnique();
      iterator string = m_data->string;
      m_data->Reset();
      return string;
   }
 
   void c_copy( iterator dst, size_type maxCharsToCopy, size_type i = 0 ) const noexcept
   {
      if ( dst != nullptr )
         if ( maxCharsToCopy > 0 )
         {
            if ( --maxCharsToCopy > 0 )
            {
               size_type len = Length();
               if ( i < len )
               {
                  size_type n = pcl::Min( maxCharsToCopy, len-i );
                  R::Copy( dst, m_data->string+i, n );
                  dst += n;
               }
            }
 
            *dst = R::Null();
         }
   }
 
   template <class R1, class A1>
   void Insert( size_type i, const GenericString<T,R1,A1>& s )
   {
      size_type n = s.Length();
      if ( n > 0 )
      {
         UninitializedGrow( i, n ); // -> 0 <= i <= len
         R::Copy( m_data->string+i, s.m_data->string, n );
      }
   }
 
   void Insert( size_type i, const_iterator p, const_iterator q )
   {
      if ( p < q )
      {
         size_type n = q - p;
         UninitializedGrow( i, n ); // -> 0 <= i <= len
         R::Copy( m_data->string+i, p, n );
      }
   }
 
   void Insert( size_type i, const_c_string t )
   {
      size_type n = R::Length( t );
      if ( n > 0 )
      {
         UninitializedGrow( i, n ); // -> 0 <= i <= len
         R::Copy( m_data->string+i, t, n );
      }
   }
 
   void Insert( size_type i, const_c_string t, size_type n )
   {
      if ( (n = pcl::Min( n, R::Length( t ) )) > 0 )
      {
         UninitializedGrow( i, n ); // -> 0 <= i <= len
         R::Copy( m_data->string+i, t, n );
      }
   }
 
   void Insert( size_type i, char_type c, size_type n = 1 )
   {
      if ( n > 0 )
      {
         UninitializedGrow( i, n ); // -> 0 <= i <= len
         R::Fill( m_data->string+i, c, n );
      }
   }
 
   template <class R1, class A1>
   void Append( const GenericString<T,R1,A1>& s )
   {
      Insert( maxPos, s );
   }
 
   template <class R1, class A1>
   GenericString& operator +=( const GenericString<T,R1,A1>& s )
   {
      Append( s );
      return *this;
   }
 
   void Append( const_iterator i, const_iterator j )
   {
      Insert( maxPos, i, j );
   }
 
   void Append( const_c_string t, size_type n )
   {
      Insert( maxPos, t, n );
   }
 
   void Append( const_c_string t )
   {
      Insert( maxPos, t );
   }
 
   GenericString& operator +=( const_c_string t )
   {
      Append( t );
      return *this;
   }
 
   void Append( char_type c, size_type n = 1 )
   {
      Insert( maxPos, c, n );
   }
 
   template <class R1, class A1>
   void Add( const GenericString<T,R1,A1>& s )
   {
      Append( s );
   }
 
   void Add( const_iterator i, const_iterator j )
   {
      Append( i, j );
   }
 
   void Add( const_c_string t, size_type n )
   {
      Append( t, n );
   }
 
   void Add( const_c_string t )
   {
      Append( t );
   }
 
   void Add( char_type c, size_type n = 1 )
   {
      Append( c, n );
   }
 
   GenericString& operator +=( char_type c )
   {
      Append( c );
      return *this;
   }
 
   template <class R1, class A1>
   void Prepend( const GenericString<T,R1,A1>& s )
   {
      Insert( 0, s );
   }
 
   template <class R1, class A1>
   GenericString& operator -=( const GenericString<T,R1,A1>& s )
   {
      Prepend( s );
      return *this;
   }
 
   void Prepend( const_iterator i, const_iterator j )
   {
      Insert( 0, i, j );
   }
 
   void Prepend( const_c_string t, size_type n )
   {
      Insert( 0, t, n );
   }
 
   void Prepend( const_c_string t )
   {
      Insert( 0, t );
   }
 
   GenericString& operator -=( const_c_string t )
   {
      Prepend( t );
      return *this;
   }
 
   void Prepend( char_type c, size_type n = 1 )
   {
      Insert( 0, c, n );
   }
 
   GenericString& operator -=( char_type c )
   {
      Prepend( c );
      return *this;
   }
 
   template <class R1, class A1>
   void Replace( size_type i, size_type n, const GenericString<T,R1,A1>& s )
   {
      if ( n > 0 )
      {
         size_type len = Length();
         if ( i < len )
         {
            n = pcl::Min( n, len-i );
            if ( n != len )
            {
               size_type ns = s.Length();
               if ( ns > 0 )
               {
                  if ( n < ns )
                     UninitializedGrow( i, ns-n );
                  else if ( ns < n )
                     Delete( i, n-ns );
                  else
                     EnsureUnique();
 
                  R::Copy( m_data->string+i, s.m_data->string, ns );
               }
               else
                  Delete( i, n );
            }
            else
               Assign( s );
         }
      }
   }
 
   void Replace( size_type i, size_type n, const_c_string t )
   {
      if ( n > 0 )
      {
         size_type len = Length();
         if ( i < len )
         {
            n = pcl::Min( n, len-i );
            if ( n != len )
            {
               size_type nt = R::Length( t );
               if ( nt > 0 )
               {
                  if ( n < nt )
                     UninitializedGrow( i, nt-n );
                  else if ( nt < n )
                     Delete( i, n-nt );
                  else
                     EnsureUnique();
 
                  R::Copy( m_data->string+i, t, nt );
               }
               else
                  Delete( i, n );
            }
            else
               Assign( t );
         }
      }
   }
 
   void Replace( size_type i, size_type n, char_type c, size_type nc = 1 )
   {
      if ( n > 0 )
      {
         size_type len = Length();
         if ( i < len )
         {
            n = pcl::Min( n, len-i );
            if ( n != len )
            {
               if ( nc > 0 )
               {
                  if ( n < nc )
                     UninitializedGrow( i, nc-n );
                  else if ( nc < n )
                     Delete( i, n-nc );
                  else
                     EnsureUnique();
 
                  R::Fill( m_data->string+i, c, nc );
               }
               else
                  Delete( i, n );
            }
            else
               Assign( c, nc );
         }
      }
   }
 
   void ReplaceChar( char_type c1, char_type c2, size_type i = 0, size_type n = maxPos )
   {
      ReplaceChar( c1, c2, i, n, true/*case*/ );
   }
 
   void ReplaceCharIC( char_type c1, char_type c2, size_type i = 0, size_type n = maxPos )
   {
      ReplaceChar( c1, c2, i, n, false/*case*/ );
   }
 
   template <class R1, class A1, class R2, class A2>
   void ReplaceString( const GenericString<T,R1,A1>& s1,
                       const GenericString<T,R2,A2>& s2, size_type i = 0 )
   {
      ReplaceString( s1.m_data->string, s1.Length(), s2.m_data->string, s2.Length(), i, true/*case*/ );
   }
 
   void ReplaceString( const_c_string t1, const_c_string t2, size_type i = 0 )
   {
      ReplaceString( t1, R::Length( t1 ), t2, R::Length( t2 ), i, true/*case*/ );
   }
 
   template <class R1, class A1, class R2, class A2>
   void ReplaceStringIC( const GenericString<T,R1,A1>& s1,
                         const GenericString<T,R2,A2>& s2, size_type i = 0 )
   {
      ReplaceString( s1.m_data->string, s1.Length(), s2.m_data->string, s2.Length(), i, false/*case*/ );
   }
 
   void ReplaceStringIC( const_c_string t1, const_c_string t2, size_type i = 0 )
   {
      ReplaceString( t1, R::Length( t1 ), t2, R::Length( t2 ), i, false/*case*/ );
   }
 
   void Delete( size_type i, size_type n = 1 )
   {
      if ( n > 0 )
      {
         size_type len = Length();
         if ( i < len )
         {
            n = pcl::Min( n, len-i );
            if ( n < len )
            {
               size_type newLen = len-n;
               if ( !IsUnique() || m_data->ShouldReallocate( newLen ) )
               {
                  Data* newData = Data::New( newLen );
                  if ( i > 0 )
                     R::Copy( newData->string, m_data->string, i );
                  if ( i < newLen )
                     R::Copy( newData->string+i, m_data->string+i+n, newLen-i );
                  DetachFromData();
                  m_data = newData;
               }
               else
               {
                  if ( i < newLen )
                     R::CopyOverlapped( m_data->string+i, m_data->string+i+n, newLen-i );
                  m_data->SetLength( newLen );
               }
            }
            else
               Clear();
         }
      }
   }
 
   void DeleteRight( size_type i )
   {
      Delete( i, maxPos );
   }
 
   void DeleteLeft( size_type i )
   {
      Delete( 0, i );
   }
 
   void DeleteChar( char_type c, size_type i = 0 )
   {
      ReplaceString( &c, 1, nullptr, 0, i, true/*case*/ );
   }
 
   void DeleteCharIC( char_type c, size_type i = 0 )
   {
      ReplaceString( &c, 1, nullptr, 0, i, false/*case*/ );
   }
 
   template <class R1, class A1>
   void DeleteString( const GenericString<T,R1,A1>& s, size_type i = 0 )
   {
      ReplaceString( s.m_data->string, s.Length(), nullptr, 0, i, true/*case*/ );
   }
 
   void DeleteString( const_c_string t, size_type i = 0 )
   {
      ReplaceString( t, R::Length( t ), nullptr, 0, i, true/*case*/ );
   }
 
   template <class R1, class A1>
   void DeleteStringIC( const GenericString<T,R1,A1>& s, size_type i = 0 )
   {
      ReplaceString( s.m_data->string, s.Length(), nullptr, 0, i, false/*case*/ );
   }
 
   void DeleteStringIC( const_c_string t, size_type i = 0 )
   {
      ReplaceString( t, R::Length( t ), nullptr, 0, i, false/*case*/ );
   }
 
   void Clear()
   {
      if ( !IsEmpty() )
         if ( IsUnique() )
            m_data->Deallocate();
         else
         {
            Data* newData = Data::New();
            DetachFromData();
            m_data = newData;
         }
   }
 
   GenericString Substring( size_type i, size_type n = maxPos ) const
   {
      size_type len = Length();
      if ( i < len )
      {
         n = pcl::Min( n, len-i );
         if ( n > 0 )
         {
            if ( n < len )
            {
               GenericString t;
               t.m_data->Allocate( n );
               R::Copy( t.m_data->string, m_data->string+i, n );
               return t;
            }
            return *this;
         }
      }
      return GenericString();
   }
 
   GenericString Left( size_type n ) const
   {
      size_type len = Length();
      n = pcl::Min( n, len );
      if ( n > 0 )
      {
         if ( n < len )
         {
            GenericString t;
            t.m_data->Allocate( n );
            R::Copy( t.m_data->string, m_data->string, n );
            return t;
         }
         return *this;
      }
      return GenericString();
   }
 
   GenericString Right( size_type n ) const
   {
      size_type len = Length();
      n = pcl::Min( n, len );
      if ( n > 0 )
      {
         if ( n < len )
         {
            GenericString t;
            t.m_data->Allocate( n );
            R::Copy( t.m_data->string, m_data->string+len-n, n );
            return t;
         }
         return *this;
      }
      return GenericString();
   }
 
   GenericString Suffix( size_type i ) const
   {
      return Substring( i );
   }
 
   GenericString Prefix( size_type i ) const
   {
      return Left( (i > 0) ? i-1 : 0 );
   }
 
   template <class C, class R1, class A1>
   size_type Break( C& list, const GenericString<T,R1,A1>& s, bool trim = false, size_type i = 0 ) const
   {
      size_type count = 0;
      size_type len = Length();
      if ( i < len )
      {
         size_type n = s.Length();
         if ( n > 0 )
            for ( SearchEngine S( s.m_data->string, n, true/*case*/ ); ; )
            {
               size_type j = S( m_data->string, i, len );
 
               GenericString t;
               if ( i < j )
               {
                  const_iterator l = m_data->string + i;
                  size_type m = j - i;
                  if ( trim )
                  {
                     const_iterator r = l + m;
                     l = R::SearchTrimLeft( l, r );
                     m = R::SearchTrimRight( l, r ) - l;
                  }
                  if ( m > 0 )
                  {
                     t.m_data->Allocate( m );
                     R::Copy( t.m_data->string, l, m );
                  }
               }
               list.Add( t );
               ++count;
 
               if ( j == len )
                  break;
 
               i = j + n;
            }
      }
      return count;
   }
 
   template <class C>
   size_type Break( C& list, const_c_string s, bool trim = false, size_type i = 0 ) const
   {
      size_type count = 0;
      size_type len = Length();
      if ( i < len )
      {
         size_type n = R::Length( s );
         if ( n > 0 )
            for ( SearchEngine S( s, n, true/*case*/ ); ; )
            {
               size_type j = S( m_data->string, i, len );
 
               GenericString t;
               if ( i < j )
               {
                  const_iterator l = m_data->string + i;
                  size_type m = j - i;
                  if ( trim )
                  {
                     const_iterator r = l + m;
                     l = R::SearchTrimLeft( l, r );
                     m = R::SearchTrimRight( l, r ) - l;
                  }
                  if ( m > 0 )
                  {
                     t.m_data->Allocate( m );
                     R::Copy( t.m_data->string, l, m );
                  }
               }
               list.Add( t );
               ++count;
 
               if ( j == len )
                  break;
 
               i = j + n;
            }
      }
      return count;
   }
 
   template <class C>
   size_type Break( C& list, char_type c, bool trim = false, size_type i = 0 ) const
   {
      size_type count = 0;
      size_type len = Length();
      if ( i < len )
      {
         for ( ;; )
         {
            size_type j = i;
            for ( const_iterator p = m_data->string + i; j < len; ++j, ++p )
               if ( *p == c )
                  break;
 
            GenericString t;
            if ( i < j )
            {
               const_iterator l = m_data->string + i;
               size_type m = j - i;
               if ( trim )
               {
                  const_iterator r = l + m;
                  l = R::SearchTrimLeft( l, r );
                  m = R::SearchTrimRight( l, r ) - l;
               }
               if ( m > 0 )
               {
                  t.m_data->Allocate( m );
                  R::Copy( t.m_data->string, l, m );
               }
            }
            list.Add( t );
            ++count;
 
            if ( j == len )
               break;
 
            i = j + 1;
         }
      }
      return count;
   }
 
   template <class C, typename S>
   size_type Break( C& list, const Array<S>& ca, bool trim = false, size_type i = 0 ) const
   {
      size_type count = 0;
      if ( !ca.IsEmpty() )
      {
         size_type len = Length();
         if ( i < len )
         {
            for ( ;; )
            {
               size_type j = i;
               for ( const_iterator p = m_data->string + i; j < len; ++j, ++p )
                  for ( auto c : ca )
                     if ( *p == char_type( c ) )
                        goto __Break_1;
__Break_1:
               GenericString t;
               if ( i < j )
               {
                  const_iterator l = m_data->string + i;
                  size_type m = j - i;
                  if ( trim )
                  {
                     const_iterator r = l + m;
                     l = R::SearchTrimLeft( l, r );
                     m = R::SearchTrimRight( l, r ) - l;
                  }
                  if ( m > 0 )
                  {
                     t.m_data->Allocate( m );
                     R::Copy( t.m_data->string, l, m );
                  }
               }
               list.Add( t );
               ++count;
 
               if ( j == len )
                  break;
 
               i = j + 1;
            }
         }
      }
      return count;
   }
 
   template <class C, class R1, class A1>
   size_type BreakIC( C& list, const GenericString<T,R1,A1>& s, bool trim = false, size_type i = 0 ) const
   {
      size_type count = 0;
      size_type len = Length();
      if ( i < len )
      {
         size_type n = s.Length();
         if ( n > 0 )
         {
            for ( SearchEngine S( s.m_data->string, n, false/*case*/ ); ; )
            {
               size_type j = S( m_data->string, i, len );
 
               GenericString t;
               if ( i < j )
               {
                  const_iterator l = m_data->string + i;
                  size_type m = j - i;
                  if ( trim )
                  {
                     const_iterator r = l + m;
                     l = R::SearchTrimLeft( l, r );
                     m = R::SearchTrimRight( l, r ) - l;
                  }
                  if ( m > 0 )
                  {
                     t.m_data->Allocate( m );
                     R::Copy( t.m_data->string, l, m );
                  }
               }
               list.Add( t );
               ++count;
 
               if ( j == len )
                  break;
 
               i = j + n;
            }
         }
      }
      return count;
   }
 
   template <class C>
   size_type BreakIC( C& list, const_c_string s, bool trim = false, size_type i = 0 ) const
   {
      size_type count = 0;
      size_type len = Length();
      if ( i < len )
      {
         size_type n = R::Length( s );
         if ( n > 0 )
         {
            for ( SearchEngine S( s, n, false/*case*/ ); ; )
            {
               size_type j = S( m_data->string, i, len );
 
               GenericString t;
               if ( i < j )
               {
                  const_iterator l = m_data->string + i;
                  size_type m = j - i;
                  if ( trim )
                  {
                     const_iterator r = l + m;
                     l = R::SearchTrimLeft( l, r );
                     m = R::SearchTrimRight( l, r ) - l;
                  }
                  if ( m > 0 )
                  {
                     t.m_data->Allocate( m );
                     R::Copy( t.m_data->string, l, m );
                  }
               }
               list.Add( t );
               ++count;
 
               if ( j == len )
                  break;
 
               i = j + n;
            }
         }
      }
      return count;
   }
 
   template <class C>
   size_type BreakIC( C& list, char_type c, bool trim = false, size_type i = 0 ) const
   {
      size_type count = 0;
      size_type len = Length();
      if ( i < len )
      {
         c = R::ToCaseFolded( c );
         for ( ;; )
         {
            size_type j = i;
            for ( const_iterator p = m_data->string + i; j < len; ++j, ++p )
               if ( R::ToCaseFolded( *p ) == c )
                  break;
 
            GenericString t;
            if ( i < j )
            {
               const_iterator l = m_data->string + i;
               size_type m = j - i;
               if ( trim )
               {
                  const_iterator r = l + m;
                  l = R::SearchTrimLeft( l, r );
                  m = R::SearchTrimRight( l, r ) - l;
               }
               if ( m > 0 )
               {
                  t.m_data->Allocate( m );
                  R::Copy( t.m_data->string, l, m );
               }
            }
            list.Add( t );
            ++count;
 
            if ( j == len )
               break;
 
            i = j + 1;
         }
      }
      return count;
   }
 
   char_type FirstChar() const noexcept
   {
      return (m_data->string != nullptr) ? *m_data->string : R::Null();
   }
 
   char_type LastChar() const noexcept
   {
      return (m_data->string < m_data->end) ? *(m_data->end-1) : R::Null();
   }
 
   template <class R1, class A1>
   bool StartsWith( const GenericString<T,R1,A1>& s ) const noexcept
   {
      if ( s.IsEmpty() || Length() < s.Length() )
         return false;
      for ( const_iterator p = m_data->string, q = s.m_data->string; q < s.m_data->end; ++p, ++q )
         if ( *p != *q )
            return false;
      return true;
   }
 
   bool StartsWith( const_c_string t ) const noexcept
   {
      size_type n = R::Length( t );
      if ( n == 0 || Length() < n )
         return false;
      for ( const_iterator p = m_data->string, e = p+n; p < e; ++p, ++t )
         if ( *p != *t )
            return false;
      return true;
   }
 
   bool StartsWith( char_type c ) const noexcept
   {
      return m_data->string < m_data->end && *m_data->string == c;
   }
 
   template <class R1, class A1>
   bool StartsWithIC( const GenericString<T,R1,A1>& s ) const noexcept
   {
      if ( s.IsEmpty() || Length() < s.Length() )
         return false;
      for ( const_iterator p = m_data->string, q = s.m_data->string; q < s.m_data->end; ++p, ++q )
         if ( R::ToCaseFolded( *p ) != R::ToCaseFolded( *q ) )
            return false;
      return true;
   }
 
   bool StartsWithIC( const_c_string t ) const noexcept
   {
      size_type n = R::Length( t );
      if ( n == 0 || Length() < n )
         return false;
      for ( const_iterator p = m_data->string, e = p+n; p < e; ++p, ++t )
         if ( R::ToCaseFolded( *p ) != R::ToCaseFolded( *t ) )
            return false;
      return true;
   }
 
   bool StartsWithIC( char_type c ) const noexcept
   {
      return m_data->string < m_data->end && R::ToCaseFolded( *m_data->string ) == R::ToCaseFolded( c );
   }
 
   template <class R1, class A1>
   bool EndsWith( const GenericString<T,R1,A1>& s ) const noexcept
   {
      size_type n = s.Length();
      if ( n == 0 || Length() < n )
         return false;
      for ( const_iterator p = m_data->end-n, q = s.m_data->string; p < m_data->end; ++p, ++q )
         if ( *p != *q )
            return false;
      return true;
   }
 
   bool EndsWith( const_c_string t ) const noexcept
   {
      size_type n = R::Length( t );
      if ( n == 0 || Length() < n )
         return false;
      for ( const_iterator p = m_data->end-n; p < m_data->end; ++p, ++t )
         if ( *p != *t )
            return false;
      return true;
   }
 
   bool EndsWith( char_type c ) const noexcept
   {
      return m_data->string < m_data->end && *(m_data->end-1) == c;
   }
 
   template <class R1, class A1>
   bool EndsWithIC( const GenericString<T,R1,A1>& s ) const noexcept
   {
      size_type n = s.Length();
      if ( n == 0 || Length() < n )
         return false;
      for ( const_iterator p = m_data->end-n, q = s.m_data->string; p < m_data->end; ++p, ++q )
         if ( R::ToCaseFolded( *p ) != R::ToCaseFolded( *q ) )
            return false;
      return true;
   }
 
   bool EndsWithIC( const_c_string t ) const noexcept
   {
      size_type n = R::Length( t );
      if ( n == 0 || Length() < n )
         return false;
      for ( const_iterator p = m_data->end-n; p < m_data->end; ++p, ++t )
         if ( R::ToCaseFolded( *p ) != R::ToCaseFolded( *t ) )
            return false;
      return true;
   }
 
   bool EndsWithIC( char_type c ) const noexcept
   {
      return m_data->string < m_data->end && R::ToCaseFolded( *(m_data->end-1) ) == R::ToCaseFolded( c );
   }
 
   template <class R1, class A1>
   size_type FindFirst( const GenericString<T,R1,A1>& s, size_type i = 0 ) const noexcept
   {
      size_type len = Length();
      i = SearchEngine( s.m_data->string, s.Length(), true/*case*/ )( m_data->string, i, len );
      return (i < len) ? i : notFound;
   }
 
   size_type FindFirst( const_c_string t, size_type i = 0 ) const noexcept
   {
      size_type len = Length();
      i = SearchEngine( t, R::Length( t ), true/*case*/ )( m_data->string, i, len );
      return (i < len) ? i : notFound;
   }
 
   size_type FindFirst( char_type c, size_type i = 0 ) const noexcept
   {
      for ( const_iterator p = m_data->string+i; p < m_data->end; ++p )
         if ( *p == c )
            return p - m_data->string;
      return notFound;
   }
 
   template <class R1, class A1>
   size_type FindFirstIC( const GenericString<T,R1,A1>& s, size_type i = 0 ) const noexcept
   {
      size_type len = Length();
      i = SearchEngine( s.m_data->string, s.Length(), false/*case*/ )( m_data->string, i, len );
      return (i < len) ? i : notFound;
   }
 
   size_type FindFirstIC( const_c_string t, size_type i = 0 ) const noexcept
   {
      size_type len = Length();
      i = SearchEngine( t, R::Length( t ), false/*case*/ )( m_data->string, i, len );
      return (i < len) ? i : notFound;
   }
 
   size_type FindFirstIC( char_type c, size_type i = 0 ) const noexcept
   {
      c = R::ToCaseFolded( c );
      for ( const_iterator p = m_data->string+i; p < m_data->end; ++p )
         if ( R::ToCaseFolded( *p ) == c )
            return p - m_data->string;
      return notFound;
   }
 
   template <class R1, class A1>
   size_type Find( const GenericString<T,R1,A1>& s, size_type i = 0 ) const noexcept
   {
      return FindFirst( s, i );
   }
 
   size_type Find( const_c_string t, size_type i = 0 ) const noexcept
   {
      return FindFirst( t, i );
   }
 
   size_type Find( char_type c, size_type i = 0 ) const noexcept
   {
      return FindFirst( c, i );
   }
 
   template <class R1, class A1>
   size_type FindIC( const GenericString<T,R1,A1>& s, size_type i = 0 ) const noexcept
   {
      return FindFirstIC( s, i );
   }
 
   size_type FindIC( const_c_string t, size_type i = 0 ) const noexcept
   {
      return FindFirstIC( t, i );
   }
 
   size_type FindIC( char_type c, size_type i = 0 ) const noexcept
   {
      return FindFirstIC( c, i );
   }
 
   template <class R1, class A1>
   size_type FindLast( const GenericString<T,R1,A1>& s, size_type r = maxPos ) const noexcept
   {
      r = pcl::Min( r, Length() );
      size_type i = SearchEngine( s.m_data->string, s.Length(), true/*case*/, true/*last*/ )( m_data->string, 0, r );
      return (i < r) ? i : notFound;
   }
 
   size_type FindLast( const_c_string t, size_type r = maxPos ) const noexcept
   {
      r = pcl::Min( r, Length() );
      size_type i = SearchEngine( t, R::Length( t ), true/*case*/, true/*last*/ )( m_data->string, 0, r );
      return (i < r) ? i : notFound;
   }
 
   size_type FindLast( char_type c, size_type r = maxPos ) const noexcept
   {
      r = pcl::Min( r, Length() );
      for ( const_iterator p = m_data->string+r; r > 0; --r )
         if ( *--p == c )
            return r - 1;
      return notFound;
   }
 
   template <class R1, class A1>
   size_type FindLastIC( const GenericString<T,R1,A1>& s, size_type r = maxPos ) const noexcept
   {
      r = pcl::Min( r, Length() );
      size_type i = SearchEngine( s.m_data->string, s.Length(), false/*case*/, true/*last*/ )( m_data->string, 0, r );
      return (i < r) ? i : notFound;
   }
 
   size_type FindLastIC( const_c_string t, size_type r = maxPos ) const noexcept
   {
      r = pcl::Min( r, Length() );
      size_type i = SearchEngine( t, R::Length( t ), false/*case*/, true/*last*/ )( m_data->string, 0, r );
      return (i < r) ? i : notFound;
   }
 
   size_type FindLastIC( char_type c, size_type r = maxPos ) const noexcept
   {
      c = R::ToCaseFolded( c );
      r = pcl::Min( r, Length() );
      for ( const_iterator p = m_data->string+r; r > 0; --r )
         if ( R::ToCaseFolded( *--p ) == c )
            return r - 1;
      return notFound;
   }
 
   template <class R1, class A1>
   bool Contains( const GenericString<T,R1,A1>& s ) const noexcept
   {
      return Find( s ) != notFound;
   }
 
   bool Contains( const_c_string t ) const noexcept
   {
      return Find( t ) != notFound;
   }
 
   bool Contains( char_type c ) const noexcept
   {
      return Find( c ) != notFound;
   }
 
   template <class R1, class A1>
   bool ContainsIC( const GenericString<T,R1,A1>& s ) const noexcept
   {
      return FindIC( s ) != notFound;
   }
 
   bool ContainsIC( const_c_string t ) const noexcept
   {
      return FindIC( t ) != notFound;
   }
 
   bool ContainsIC( char_type c ) const noexcept
   {
      return FindIC( c ) != notFound;
   }
 
   void Trim()
   {
      const_iterator l = R::SearchTrimLeft( m_data->string, m_data->end );
      const_iterator r = R::SearchTrimRight( l, m_data->end );
      if ( m_data->string < l || r < m_data->end )
         Trim( l, r - l );
   }
 
   void TrimLeft()
   {
      const_iterator l = R::SearchTrimLeft( m_data->string, m_data->end );
      if ( m_data->string < l )
         Trim( l, m_data->end - l );
   }
 
   void TrimRight()
   {
      const_iterator r = R::SearchTrimRight( m_data->string, m_data->end );
      if ( r < m_data->end )
         Trim( m_data->string, r - m_data->string );
   }
 
   GenericString Trimmed() const
   {
      GenericString s( *this );
      s.Trim();
      return s;
   }
 
   GenericString TrimmedLeft() const
   {
      GenericString s( *this );
      s.TrimLeft();
      return s;
   }
 
   GenericString TrimmedRight() const
   {
      GenericString s( *this );
      s.TrimRight();
      return s;
   }
 
   void EnsureEnclosed( char_type c )
   {
      int encloseLeft = 1;
      int encloseRight = 1;
      size_type len = Length();
      if ( len > 0 )
      {
         if ( *m_data->string == c )
            encloseLeft = 0;
         if ( *(m_data->end-1) == c )
            if ( len > 1 )
               encloseRight = 0;
            else
               encloseLeft = 0;
      }
      size_type n = len + encloseLeft + encloseRight;
      if ( n > len )
      {
         if ( !IsUnique() || m_data->ShouldReallocate( n ) )
         {
            Data* newData = Data::New( n );
            R::Copy( newData->string + encloseLeft, m_data->string, len );
            DetachFromData();
            m_data = newData;
         }
         else
         {
            m_data->SetLength( n );
            R::CopyOverlapped( m_data->string + encloseLeft, m_data->string, len );
         }
 
         if ( encloseLeft )
            *m_data->string = c;
         if ( encloseRight )
            *(m_data->end-1) = c;
      }
   }
 
   GenericString Enclosed( char_type c ) const
   {
      GenericString s( *this );
      s.EnsureEnclosed( c );
      return s;
   }
 
   void EnsureSingleQuoted()
   {
      EnsureEnclosed( R::SingleQuote() );
   }
 
   GenericString SingleQuoted() const
   {
      GenericString s( *this );
      s.EnsureSingleQuoted();
      return s;
   }
 
   void EnsureDoubleQuoted()
   {
      EnsureEnclosed( R::DoubleQuote() );
   }
 
   GenericString DoubleQuoted() const
   {
      GenericString s( *this );
      s.EnsureDoubleQuoted();
      return s;
   }
 
   void Unquote()
   {
      size_type len = Length();
      if ( len > 1 )
         if ( *m_data->string == R::SingleQuote() && *(m_data->end-1) == R::SingleQuote() ||
              *m_data->string == R::DoubleQuote() && *(m_data->end-1) == R::DoubleQuote() )
            if ( IsUnique() )
            {
               R::CopyOverlapped( m_data->string, m_data->string+1, len-2 );
               m_data->SetLength( len-2 );
            }
            else
            {
               Data* newData = Data::New( len-2 );
               R::Copy( newData->string, m_data->string+1, len-2 );
               DetachFromData();
               m_data = newData;
            }
   }
 
   GenericString Unquoted() const
   {
      GenericString s( *this );
      s.Unquote();
      return s;
   }
 
   void JustifyLeft( size_type width, char_type fill = R::Blank() )
   {
      size_type len = Length();
      if ( len < width )
         Append( fill, width-len );
   }
 
   void JustifyRight( size_type width, char_type fill = R::Blank() )
   {
      size_type len = Length();
      if ( len < width )
         Prepend( fill, width-len );
   }
 
   void JustifyCenter( size_type width, char_type fill = R::Blank() )
   {
      size_type len = Length();
      if ( len < width )
      {
         size_type n = width-len;
         size_type n2 = n >> 1;
         Prepend( fill, n2 );
         Append( fill, n-n2 );
      }
   }
 
   GenericString LeftJustified( size_type width, char_type fill = R::Blank() ) const
   {
      GenericString s( *this );
      s.JustifyLeft( width, fill );
      return s;
   }
 
   GenericString RightJustified( size_type width, char_type fill = R::Blank() ) const
   {
      GenericString s( *this );
      s.JustifyRight( width, fill );
      return s;
   }
 
   GenericString CenterJustified( size_type width, char_type fill = R::Blank() ) const
   {
      GenericString s( *this );
      s.JustifyCenter( width, fill );
      return s;
   }
 
   template <class R1, class A1>
   int CompareCodePoints( const GenericString<T,R1,A1>& s, bool caseSensitive = true ) const noexcept
   {
      return R::CompareCodePoints( m_data->string, Length(), s.m_data->string, s.Length(), caseSensitive );
   }
 
   int CompareCodePoints( const_c_string t, bool caseSensitive = true ) const noexcept
   {
      return R::CompareCodePoints( m_data->string, Length(), t, R::Length( t ), caseSensitive );
   }
 
   int CompareCodePoints( char_type c, bool caseSensitive = true ) const noexcept
   {
      return R::CompareCodePoints( m_data->string, Length(), &c, 1, caseSensitive );
   }
 
   template <class R1, class A1>
   int Compare( const GenericString<T,R1,A1>& s,
                bool caseSensitive = true, bool localeAware = true ) const noexcept
   {
      return R::Compare( m_data->string, Length(), s.m_data->string, s.Length(), caseSensitive, localeAware );
   }
 
   int Compare( const_c_string t, bool caseSensitive = true, bool localeAware = true ) const noexcept
   {
      return R::Compare( m_data->string, Length(), t, R::Length( t ), caseSensitive, localeAware );
   }
 
   int Compare( char_type c, bool caseSensitive = true, bool localeAware = true ) const noexcept
   {
      return R::Compare( m_data->string, Length(), &c, 1, caseSensitive, localeAware );
   }
 
   template <class R1, class A1>
   int CompareIC( const GenericString<T,R1,A1>& s, bool localeAware = true ) const noexcept
   {
      return R::Compare( m_data->string, Length(), s.m_data->string, s.Length(), false/*caseSensitive*/, localeAware );
   }
 
   int CompareIC( const_c_string t, bool localeAware = true ) const noexcept
   {
      return R::Compare( m_data->string, Length(), t, R::Length( t ), false/*caseSensitive*/, localeAware );
   }
 
   int CompareIC( char_type c, bool localeAware = true ) const noexcept
   {
      return R::Compare( m_data->string, Length(), &c, 1, false/*caseSensitive*/, localeAware );
   }
 
   template <class R1, class A1>
   bool WildMatch( const GenericString<T,R1,A1>& pattern, bool caseSensitive = true ) const noexcept
   {
      return R::WildMatch( m_data->string, Length(), pattern.m_data->string, pattern.Length(), caseSensitive );
   }
 
   template <class R1, class A1>
   bool WildMatchIC( const GenericString<T,R1,A1>& pattern ) const noexcept
   {
      return R::WildMatch( m_data->string, Length(), pattern.m_data->string, pattern.Length(), false/*caseSensitive*/ );
   }
 
   bool WildMatch( const_c_string pattern, bool caseSensitive = true ) const noexcept
   {
      return R::WildMatch( m_data->string, Length(), pattern, R::Length( pattern ), caseSensitive );
   }
 
   bool WildMatchIC( const_c_string pattern ) const noexcept
   {
      return R::WildMatch( m_data->string, Length(), pattern, R::Length( pattern ), false/*caseSensitive*/ );
   }
 
   bool HasWildcards() const noexcept
   {
      for ( iterator i = m_data->string; i < m_data->end; ++i )
         if ( R::IsWildcard( *i ) )
            return true;
      return false;
   }
 
   void ToCaseFolded()
   {
      size_type len = Length();
      if ( len > 0 )
      {
         EnsureUnique();
         R::ToCaseFolded( m_data->string, len );
      }
   }
 
   void ToLowercase()
   {
      size_type len = Length();
      if ( len > 0 )
      {
         EnsureUnique();
         R::ToLowercase( m_data->string, len );
      }
   }
 
   void ToUppercase()
   {
      size_type len = Length();
      if ( len > 0 )
      {
         EnsureUnique();
         R::ToUppercase( m_data->string, len );
      }
   }
 
   GenericString CaseFolded() const
   {
      GenericString s( *this );
      s.ToCaseFolded();
      return s;
   }
 
   GenericString Lowercase() const
   {
      GenericString s( *this );
      s.ToLowercase();
      return s;
   }
 
   GenericString Uppercase() const
   {
      GenericString s( *this );
      s.ToUppercase();
      return s;
   }
 
   void Reverse()
   {
      if ( !IsEmpty() )
      {
         EnsureUnique();
         for ( iterator i = m_data->string, j = m_data->end; i < --j; ++i )
            pcl::Swap( *i, *j );
      }
   }
 
   GenericString Reversed() const
   {
      GenericString s( *this );
      s.Reverse();
      return s;
   }
 
   void Sort()
   {
      if ( !IsEmpty() )
      {
         EnsureUnique();
         pcl::Sort( m_data->string, m_data->end );
      }
   }
 
   GenericString Sorted() const
   {
      GenericString s( *this );
      s.Sort();
      return s;
   }
 
   template <class BP>
   void Sort( BP p )
   {
      if ( !IsEmpty() )
      {
         EnsureUnique();
         pcl::Sort( m_data->string, m_data->end, p );
      }
   }
 
   template <class BP>
   GenericString Sorted( BP p ) const
   {
      GenericString s( *this );
      s.Sort( p );
      return s;
   }
 
   bool IsNumeral() const noexcept
   {
      if ( IsEmpty() )
         return false;
      char_type c = *R::SearchTrimLeft( m_data->string, m_data->end );
      return R::IsDigit( c ) || R::IsSign( c ) || R::IsDecimalSeparator( c );
   }
 
   bool IsSymbol() const noexcept
   {
      if ( IsEmpty() )
         return false;
      char_type c = *R::SearchTrimLeft( m_data->string, m_data->end );
      return R::IsSymbolDigit( c );
   }
 
   bool IsValidIdentifier( distance_type& pos ) const noexcept
   {
      if ( IsEmpty() )
      {
         pos = 0;
         return false;
      }
      const_iterator i = m_data->string;
      if ( R::IsStartingSymbolDigit( *i ) )
         for ( ;; )
         {
            if ( ++i == m_data->end )
               return true;
            if ( !R::IsSymbolDigit( *i ) )
               break;
         }
      pos = i - m_data->string;
      return false;
   }
 
   bool IsValidIdentifier() const noexcept
   {
      if ( !IsEmpty() )
         if ( R::IsStartingSymbolDigit( *m_data->string ) )
         {
            for ( const_iterator i = m_data->string; ++i < m_data->end; )
               if ( !R::IsSymbolDigit( *i ) )
                  return false;
            return true;
         }
      return false;
   }
 
   uint64 Hash64( uint64 seed = 0 ) const noexcept
   {
      return pcl::Hash64( m_data->string, Size(), seed );
   }
 
   uint32 Hash32( uint32 seed = 0 ) const noexcept
   {
      return pcl::Hash32( m_data->string, Size(), seed );
   }
 
   uint64 Hash( uint64 seed = 0 ) const noexcept
   {
      return Hash64( seed );
   }
 
   static size_type DeleteFreeList()
   {
      return Data::DeleteFreeList();
   }
 
   // -------------------------------------------------------------------------
 
protected:
 
   void DetachFromData()
   {
      if ( !m_data->Detach() )
         Data::Dispose( m_data );
   }
 
   void MaybeReallocate( size_type len )
   {
      if ( IsUnique() )
      {
         if ( m_data->ShouldReallocate( len ) )
         {
            m_data->Deallocate();
            m_data->Allocate( len );
         }
         else
            m_data->SetLength( len );
      }
      else
      {
         Data* newData = Data::New( len );
         DetachFromData();
         m_data = newData;
      }
   }
 
   void UninitializedGrow( size_type& i, size_type n )
   {
      size_type len = Length();
      size_type newLen = len+n;
      if ( newLen > len )
      {
         if ( i > len )
            i = len;
         if ( IsUnique() )
         {
            if ( size_type( m_data->capacity - m_data->string ) < newLen+1 )
            {
               iterator old = m_data->string;
               m_data->Allocate( newLen );
               if ( old != nullptr )
               {
                  if ( i > 0 )
                     R::Copy( m_data->string, old, i );
                  if ( i < len )
                     R::Copy( m_data->string+i+n, old+i, len-i );
                  m_data->alloc.Deallocate( old );
               }
            }
            else
            {
               if ( i < len )
                  R::CopyOverlapped( m_data->string+i+n, m_data->string+i, len-i );
               m_data->SetLength( newLen );
            }
         }
         else
         {
            Data* newData = Data::New( newLen );
            if ( i > 0 )
               R::Copy( newData->string, m_data->string, i );
            if ( i < len )
               R::Copy( newData->string+i+n, m_data->string+i, len-i );
            DetachFromData();
            m_data = newData;
         }
      }
   }
 
   void Trim( const_iterator left, size_type len )
   {
      if ( len > 0 )
      {
         if ( IsUnique() )
         {
            if ( m_data->ShouldReallocate( len ) )
            {
               iterator old = m_data->string;
               m_data->Allocate( len );
               R::Copy( m_data->string, left, len );
               if ( old != nullptr )
                  m_data->alloc.Deallocate( old );
            }
            else
            {
               if ( left != m_data->string ) // trim left
                  R::CopyOverlapped( m_data->string, left, len );
               m_data->SetLength( len );     // trim right
            }
         }
         else
         {
            Data* newData = Data::New( len );
            R::Copy( newData->string, left, len );
            DetachFromData();
            m_data = newData;
         }
      }
      else
         Clear();
   }
 
   void ReplaceChar( char_type c1, char_type c2, size_type i, size_type n, bool caseSensitive )
   {
      if ( n > 0 )
      {
         size_type len = Length();
         if ( i < len )
         {
            n = pcl::Min( n, len-i );
            if ( caseSensitive )
            {
               for ( iterator p = m_data->string + i, p1 = p + n; p < p1; ++p )
                  if ( *p == c1 )
                  {
                     distance_type d = p - m_data->string;
                     EnsureUnique();
                     p = m_data->string + d;
                     *p = c2;
                     for ( iterator p1 = m_data->string + i + n; ++p < p1; )
                        if ( *p == c1 )
                           *p = c2;
                     break;
                  }
            }
            else
            {
               c1 = R::ToCaseFolded( c1 );
               for ( iterator p = m_data->string + i, p1 = p + n; p < p1; ++p )
                  if ( R::ToCaseFolded( *p ) == c1 )
                  {
                     distance_type d = p - m_data->string;
                     EnsureUnique();
                     p = m_data->string + d;
                     *p = c2;
                     for ( iterator p1 = m_data->string + i + n; ++p < p1; )
                        if ( R::ToCaseFolded( *p ) == c1 )
                           *p = c2;
                     break;
                  }
            }
         }
      }
   }
 
   void ReplaceString( const_iterator t1, size_type n1, const_iterator t2, size_type n2, size_type i, bool caseSensitive )
   {
      if ( n1 > 0 )
      {
         size_type len = Length();
         if ( i < len )
         {
            SearchEngine S( t1, n1, caseSensitive );
            if ( n1 == n2 )
            {
               EnsureUnique();
               for ( size_type p = i; (p = S( m_data->string, p, len )) < len; p += n1 )
                  R::Copy( m_data->string + p, t2, n2 );
            }
            else
            {
               Array<size_type> P;
               for ( size_type p = i; (p = S( m_data->string, p, len )) < len; p += n1 )
                  P.Add( p );
               if ( !P.IsEmpty() )
               {
                  size_type newLen = len;
                  if ( n1 < n2 )
                     newLen += P.Length()*(n2 - n1);
                  else
                     newLen -= P.Length()*(n1 - n2);
 
                  if ( newLen > 0 )
                  {
                     Data* newData = Data::New( newLen );
                     size_type targetIndex = 0;
                     size_type sourceIndex = 0;
                     for ( size_type p : P )
                     {
                        size_type n = p - sourceIndex;
                        if ( n > 0 )
                           R::Copy( newData->string+targetIndex, m_data->string+sourceIndex, n );
                        R::Copy( newData->string+targetIndex+n, t2, n2 );
                        targetIndex += n + n2;
                        sourceIndex = p + n1;
                     }
                     if ( sourceIndex < len )
                        R::Copy( newData->string+targetIndex, m_data->string+sourceIndex, len-sourceIndex );
                     DetachFromData();
                     m_data = newData;
                  }
                  else
                     Clear();
               }
            }
         }
      }
   }
 
   class PCL_CLASS SearchEngine
   {
   public:
 
      SearchEngine( const_iterator pattern, size_type patternLength,
                    bool caseSensitive = true, bool searchLast = false, bool useBoyerMoore = true )
         : m_pattern( pattern )
         , m_patternLength( int( patternLength ) )
         , m_caseSensitive( caseSensitive )
         , m_searchLast( searchLast )
         , m_useBoyerMoore( useBoyerMoore && m_patternLength > 3 )
      {
         if ( m_useBoyerMoore )
            InitSkipList();
      }
 
      size_type operator()( const_iterator text, size_type startIndex, size_type endIndex ) const noexcept
      {
         if (    endIndex <= startIndex
              || m_patternLength <= 0
              || endIndex-startIndex < size_type( m_patternLength )
              || text == nullptr
              || m_pattern == nullptr )
            return endIndex;
 
         if ( m_caseSensitive )
         {
            if ( m_useBoyerMoore )
            {
               if ( m_searchLast )
               {
                  for ( size_type i = startIndex, r = endIndex-m_patternLength; i <= r; )
                  {
                     int skip = 0;
                     const_iterator t = text + r - i;
                     const_iterator p = m_pattern;
                     for ( int j = m_patternLength; --j >= 0; )
                     {
                        char_type c = *t++;
                        if ( c != *p++ )
                        {
                           skip = j - m_skipList[uint8( c )];
                           if ( skip < 1 )
                              skip = 1;
                           break;
                        }
                     }
                     if ( skip == 0 )
                        return r - i;
                     i += skip;
                  }
               }
               else
               {
                  for ( size_type i = startIndex, r = endIndex-m_patternLength; i <= r; )
                  {
                     int skip = 0;
                     const_iterator t = text + i + m_patternLength;
                     const_iterator p = m_pattern + m_patternLength;
                     for ( int j = m_patternLength; --j >= 0; )
                     {
                        char_type c = *--t;
                        if ( c != *--p )
                        {
                           // ### N.B.: Could do better with a precomputed pattern mismatch table.
                           skip = j - m_skipList[uint8( c )];
                           if ( skip < 1 )
                              skip = 1;
                           break;
                        }
                     }
                     if ( skip == 0 )
                        return i;
                     i += skip;
                  }
               }
            }
            else
            {
               // Use a brute force search for very small patterns.
               if ( m_searchLast )
               {
                  for ( size_type i = endIndex-m_patternLength; ; --i )
                  {
                     const_iterator t = text + i;
                     const_iterator p = m_pattern;
                     for ( int j = m_patternLength; ; ++t, ++p )
                     {
                        if ( *t != *p )
                           break;
                        if ( --j == 0 )
                           return i;
                     }
                     if ( i == startIndex )
                        break;
                  }
               }
               else
               {
                  for ( size_type i = startIndex, r = endIndex-m_patternLength; ; ++i )
                  {
                     const_iterator t = text + i;
                     const_iterator p = m_pattern;
                     for ( int j = m_patternLength; ; ++t, ++p )
                     {
                        if ( *t != *p )
                           break;
                        if ( --j == 0 )
                           return i;
                     }
                     if ( i == r )
                        break;
                  }
               }
            }
         }
         else
         {
            if ( m_useBoyerMoore )
            {
               if ( m_searchLast )
               {
                  for ( size_type i = startIndex, r = endIndex-m_patternLength; i <= r; )
                  {
                     int skip = 0;
                     const_iterator t = text + r - i;
                     const_iterator p = m_pattern;
                     for ( int j = m_patternLength; --j >= 0; )
                     {
                        char_type c = R::ToCaseFolded( *t++ );
                        if ( c != R::ToCaseFolded( *p++ ) )
                        {
                           skip = j - m_skipList[uint8( c )];
                           if ( skip < 1 )
                              skip = 1;
                           break;
                        }
                     }
                     if ( skip == 0 )
                        return r - i;
                     i += skip;
                  }
               }
               else
               {
                  for ( size_type i = startIndex, r = endIndex-m_patternLength; i <= r; )
                  {
                     int skip = 0;
                     const_iterator t = text + i + m_patternLength;
                     const_iterator p = m_pattern + m_patternLength;
                     for ( int j = m_patternLength; --j >= 0; )
                     {
                        char_type c = R::ToCaseFolded( *--t );
                        if ( c != R::ToCaseFolded( *--p ) )
                        {
                           // ### N.B.: Could do better with a precomputed pattern mismatch table.
                           skip = j - m_skipList[uint8( c )];
                           if ( skip < 1 )
                              skip = 1;
                           break;
                        }
                     }
                     if ( skip == 0 )
                        return i;
                     i += skip;
                  }
               }
            }
            else
            {
               // Use a brute force search for very small patterns.
               if ( m_searchLast )
               {
                  for ( size_type i = endIndex-m_patternLength; ; --i )
                  {
                     const_iterator t = text + i;
                     const_iterator p = m_pattern;
                     for ( int j = m_patternLength; ; ++t, ++p )
                     {
                        if ( R::ToCaseFolded( *t ) != R::ToCaseFolded( *p ) )
                           break;
                        if ( --j == 0 )
                           return i;
                     }
                     if ( i == startIndex )
                        break;
                  }
               }
               else
               {
                  for ( size_type i = startIndex, r = endIndex-m_patternLength; ; ++i )
                  {
                     const_iterator t = text + i;
                     const_iterator p = m_pattern;
                     for ( int j = m_patternLength; ; ++t, ++p )
                     {
                        if ( R::ToCaseFolded( *t ) != R::ToCaseFolded( *p ) )
                           break;
                        if ( --j == 0 )
                           return i;
                     }
                     if ( i == r )
                        break;
                  }
               }
            }
         }
         return endIndex;
      }
 
   private:
 
      int            m_skipList[ 256 ];
      const_iterator m_pattern;
      int            m_patternLength;
      bool           m_caseSensitive : 1;
      bool           m_searchLast    : 1;
      bool           m_useBoyerMoore : 1;
 
      void InitSkipList() noexcept
      {
         ::memset( m_skipList, 0xff, sizeof( m_skipList ) ); // fill with -1
         if ( m_searchLast )
         {
            const_iterator p = m_pattern + m_patternLength;
            if ( m_caseSensitive )
               for ( int i = 0; i < m_patternLength; ++i )
                  m_skipList[uint8( *--p )] = i;
            else
               for ( int i = 0; i < m_patternLength; ++i )
                  m_skipList[uint8( R::ToCaseFolded( *--p ) )] = i;
         }
         else
         {
            const_iterator p = m_pattern;
            if ( m_caseSensitive )
               for ( int i = 0; i < m_patternLength; ++i )
                  m_skipList[uint8( *p++ )] = i;
            else
               for ( int i = 0; i < m_patternLength; ++i )
                  m_skipList[uint8( R::ToCaseFolded( *p++ ) )] = i;
         }
      }
   };
 
   // -------------------------------------------------------------------------
 
   class PCL_CLASS Data : public ReferenceCounter
   {
   private:
 
#ifndef __PCL_NO_STRING_FREE_LIST
      static Data*     freeList; 
      static AtomicInt freeLock; 
#endif
 
   public:
 
      iterator  string   = nullptr; 
      iterator  end      = nullptr; 
      iterator  capacity = nullptr; 
      allocator alloc;              
 
      Data() = default;
 
      Data( size_type len )
      {
         Allocate( len );
      }
 
      Data( size_type len, size_type total )
      {
         Allocate( len, total );
      }
 
      ~Data()
      {
         Deallocate();
      }
 
      void Allocate( size_type len, size_type total )
      {
         total = (len <= total) ? alloc.PagedLength( total+1 ) : len+1; // +1 is room for a null terminating character
         string = alloc.Allocate( total );
         capacity = string + total;
         SetLength( len );
      }
 
      void Allocate( size_type len )
      {
         Allocate( len, len );
      }
 
      void Reserve( size_type len, size_type total )
      {
         PCL_PRECONDITION( len <= total )
         string = alloc.Allocate( total+1 );
         capacity = string + total+1;
         SetLength( pcl::Min( len, total ) );
      }
 
      void Deallocate()
      {
         PCL_CHECK( (string == nullptr) ? end == nullptr : string < end )
         if ( string != nullptr )
         {
            alloc.Deallocate( string );
            Reset();
         }
      }
 
      bool ShouldReallocate( size_type len ) const noexcept
      {
         size_type m = capacity - string;
         return m <= len || alloc.ReallocatedLength( m, len+1 ) < (m >> 1);
      }
 
      void SetLength( size_type len ) noexcept
      {
         *(end = (string + len)) = R::Null();
      }
 
      void Reset() noexcept
      {
         string = end = capacity = nullptr;
      }
 
#ifndef __PCL_NO_STRING_FREE_LIST
      static Data* NextFree() noexcept
      {
         if ( freeLock.TestAndSet( 0, 1 ) )
         {
            Data* data = freeList;
            if ( data != nullptr )
               freeList = reinterpret_cast<Data*>( data->string );
            freeLock.Store( 0 );
            return data;
         }
         return nullptr;
      }
#endif // !__PCL_NO_STRING_FREE_LIST
 
      static Data* New()
      {
#ifndef __PCL_NO_STRING_FREE_LIST
         Data* data = NextFree();
         if ( data != nullptr )
         {
            data->string = nullptr;
            return data;
         }
#endif // !__PCL_NO_STRING_FREE_LIST
         return new Data;
      }
 
      static Data* New( size_type len )
      {
#ifndef __PCL_NO_STRING_FREE_LIST
         Data* data = NextFree();
         if ( data != nullptr )
         {
            data->Allocate( len ); // ### FIXME: If allocation fails, data is a leak.
            return data;
         }
#endif // !__PCL_NO_STRING_FREE_LIST
         return new Data( len );
      }
 
      static Data* New( size_type len, size_type total )
      {
#ifndef __PCL_NO_STRING_FREE_LIST
         Data* data = NextFree();
         if ( data != nullptr )
         {
            data->Allocate( len, total ); // ### FIXME: If allocation fails, data is a leak.
            return data;
         }
#endif // !__PCL_NO_STRING_FREE_LIST
         return new Data( len, total );
      }
 
      static void Dispose( Data* data )
      {
         PCL_PRECONDITION( data != nullptr )
         PCL_CHECK( data->RefCount() == 0 )
#ifndef __PCL_NO_STRING_FREE_LIST
         if ( freeLock.TestAndSet( 0, 1 ) )
         {
            data->Attach();
            data->Deallocate();
            data->string = reinterpret_cast<iterator>( freeList );
            freeList = data;
            freeLock.Store( 0 );
         }
         else
#endif // !__PCL_NO_STRING_FREE_LIST
            delete data;
      }
 
      static size_type DeleteFreeList()
      {
         size_type count = 0;
#ifndef __PCL_NO_STRING_FREE_LIST
         while ( freeList != nullptr )
         {
            Data* data = freeList;
            freeList = reinterpret_cast<Data*>( data->string );
            data->string = nullptr;
            delete data;
            ++count;
         }
#endif // !__PCL_NO_STRING_FREE_LIST
         return count;
      }
   };
 
   /*
    * The reference-counted string data.
    */
   Data* m_data = nullptr;
};
 
#ifndef __PCL_NO_STRING_FREE_LIST
 
template <class T, class R, class A>
typename GenericString<T,R,A>::Data* GenericString<T,R,A>::Data::freeList = nullptr;
 
template <class T, class R, class A>
AtomicInt GenericString<T,R,A>::Data::freeLock;
 
#endif // !__PCL_NO_STRING_FREE_LIST
 
template <class T, class R, class A> inline
void Swap( GenericString<T,R,A>& s1, GenericString<T,R,A>& s2 ) noexcept
{
   s1.Swap( s2 );
}
 
// ----------------------------------------------------------------------------
 
// ----------------------------------------------------------------------------
 
template <class T, class R1, class A1, class R2, class A2> inline
bool operator ==( const GenericString<T,R1,A1>& s1, const GenericString<T,R2,A2>& s2 ) noexcept
{
   return s1.CompareCodePoints( s2 ) == 0;
}
 
template <class T, class R1, class A1, class R2, class A2> inline
bool operator  <( const GenericString<T,R1,A1>& s1, const GenericString<T,R2,A2>& s2 ) noexcept
{
   return s1.CompareCodePoints( s2 ) < 0;
}
 
template <class T, class R1, class A1, class R2, class A2> inline
bool operator <=( const GenericString<T,R1,A1>& s1, const GenericString<T,R2,A2>& s2 ) noexcept
{
   return s1.CompareCodePoints( s2 ) <= 0;
}
 
template <class T, class R1, class A1, class R2, class A2> inline
bool operator  >( const GenericString<T,R1,A1>& s1, const GenericString<T,R2,A2>& s2 ) noexcept
{
   return s1.CompareCodePoints( s2 ) > 0;
}
 
template <class T, class R1, class A1, class R2, class A2> inline
bool operator >=( const GenericString<T,R1,A1>& s1, const GenericString<T,R2,A2>& s2 ) noexcept
{
   return s1.CompareCodePoints( s2 ) >= 0;
}
 
// ----------------------------------------------------------------------------
 
template <class T, class R, class A> inline
bool operator ==( const GenericString<T,R,A>& s1, typename GenericString<T,R,A>::const_c_string t2 ) noexcept
{
   return s1.CompareCodePoints( t2 ) == 0;
}
 
template <class T, class R, class A> inline
bool operator  <( const GenericString<T,R,A>& s1, typename GenericString<T,R,A>::const_c_string t2 ) noexcept
{
   return s1.CompareCodePoints( t2 ) < 0;
}
 
template <class T, class R, class A> inline
bool operator <=( const GenericString<T,R,A>& s1, typename GenericString<T,R,A>::const_c_string t2 ) noexcept
{
   return s1.CompareCodePoints( t2 ) <= 0;
}
 
template <class T, class R, class A> inline
bool operator  >( const GenericString<T,R,A>& s1, typename GenericString<T,R,A>::const_c_string t2 ) noexcept
{
   return s1.CompareCodePoints( t2 ) > 0;
}
 
template <class T, class R, class A> inline
bool operator >=( const GenericString<T,R,A>& s1, typename GenericString<T,R,A>::const_c_string t2 ) noexcept
{
   return s1.CompareCodePoints( t2 ) >= 0;
}
 
// ----------------------------------------------------------------------------
 
template <class T, class R, class A> inline
bool operator ==( typename GenericString<T,R,A>::const_c_string t1, const GenericString<T,R,A>& s2 ) noexcept
{
   return s2.CompareCodePoints( t1 ) == 0;
}
 
template <class T, class R, class A> inline
bool operator  <( typename GenericString<T,R,A>::const_c_string t1, const GenericString<T,R,A>& s2 ) noexcept
{
   return s2.CompareCodePoints( t1 ) > 0;
}
 
template <class T, class R, class A> inline
bool operator <=( typename GenericString<T,R,A>::const_c_string t1, const GenericString<T,R,A>& s2 ) noexcept
{
   return s2.CompareCodePoints( t1 ) >= 0;
}
 
template <class T, class R, class A> inline
bool operator  >( typename GenericString<T,R,A>::const_c_string t1, const GenericString<T,R,A>& s2 ) noexcept
{
   return s2.CompareCodePoints( t1 ) < 0;
}
 
template <class T, class R, class A> inline
bool operator >=( typename GenericString<T,R,A>::const_c_string t1, const GenericString<T,R,A>& s2 ) noexcept
{
   return s2.CompareCodePoints( t1 ) <= 0;
}
 
// ----------------------------------------------------------------------------
 
template <class T, class R, class A> inline
bool operator ==( const GenericString<T,R,A>& s1, typename GenericString<T,R,A>::char_type c2 ) noexcept
{
   return s1.CompareCodePoints( c2 ) == 0;
}
 
template <class T, class R, class A> inline
bool operator  <( const GenericString<T,R,A>& s1, typename GenericString<T,R,A>::char_type c2 ) noexcept
{
   return s1.CompareCodePoints( c2 ) < 0;
}
 
template <class T, class R, class A> inline
bool operator <=( const GenericString<T,R,A>& s1, typename GenericString<T,R,A>::char_type c2 ) noexcept
{
   return s1.CompareCodePoints( c2 ) <= 0;
}
 
template <class T, class R, class A> inline
bool operator  >( const GenericString<T,R,A>& s1, typename GenericString<T,R,A>::char_type c2 ) noexcept
{
   return s1.CompareCodePoints( c2 ) > 0;
}
 
template <class T, class R, class A> inline
bool operator >=( const GenericString<T,R,A>& s1, typename GenericString<T,R,A>::char_type c2 ) noexcept
{
   return s1.CompareCodePoints( c2 ) >= 0;
}
 
// ----------------------------------------------------------------------------
 
template <class T, class R, class A> inline
bool operator ==( typename GenericString<T,R,A>::char_type c1, const GenericString<T,R,A>& s2 ) noexcept
{
   return s2.CompareCodePoints( c1 ) == 0;
}
 
template <class T, class R, class A> inline
bool operator  <( typename GenericString<T,R,A>::char_type c1, const GenericString<T,R,A>& s2 ) noexcept
{
   return s2.CompareCodePoints( c1 ) > 0;
}
 
template <class T, class R, class A> inline
bool operator <=( typename GenericString<T,R,A>::char_type c1, const GenericString<T,R,A>& s2 ) noexcept
{
   return s2.CompareCodePoints( c1 ) >= 0;
}
 
template <class T, class R, class A> inline
bool operator  >( typename GenericString<T,R,A>::char_type c1, const GenericString<T,R,A>& s2 ) noexcept
{
   return s2.CompareCodePoints( c1 ) < 0;
}
 
template <class T, class R, class A> inline
bool operator >=( typename GenericString<T,R,A>::char_type c1, const GenericString<T,R,A>& s2 ) noexcept
{
   return s2.CompareCodePoints( c1 ) <= 0;
}
 
// ----------------------------------------------------------------------------
 
class PCL_CLASS IsoString : public GenericString<char, IsoCharTraits, PCL_STRING_ALLOCATOR>
{
public:
 
   using string_base = GenericString<char, IsoCharTraits, PCL_STRING_ALLOCATOR>;
 
   using char_type = string_base::char_type;
 
   using char_traits = string_base::char_traits;
 
   using block_allocator = string_base::block_allocator;
 
   using allocator = string_base::allocator;
 
   using c_string = string_base::c_string;
 
   using const_c_string = string_base::const_c_string;
 
   using iterator = string_base::iterator;
 
   using const_iterator = string_base::const_iterator;
 
   using reverse_iterator = string_base::reverse_iterator;
 
   using const_reverse_iterator = string_base::const_reverse_iterator;
 
   using ustring_base = GenericString<char16_type, CharTraits, PCL_STRING_ALLOCATOR>;
 
   using uchar_type = ustring_base::char_type;
 
   using uchar_traits = ustring_base::char_traits;
 
   using c_ustring = ustring_base::c_string;
 
   using const_c_ustring = ustring_base::const_c_string;
 
   using uchar_iterator = ustring_base::iterator;
 
   using const_uchar_iterator = ustring_base::const_iterator;
 
   // -------------------------------------------------------------------------
 
   IsoString() = default;
 
   IsoString( const string_base& s )
      : string_base( s )
   {
   }
 
   IsoString( const IsoString& ) = default;
 
   IsoString( string_base&& s )
      : string_base( std::move( s ) )
   {
   }
 
   IsoString( IsoString&& ) = default;
 
   explicit
   IsoString( const ustring_base& s )
   {
      (void)operator =( s );
   }
 
   IsoString( const_c_string t )
      : string_base( t )
   {
   }
 
   IsoString( const_c_string t, size_type i, size_type n )
      : string_base( t, i, n )
   {
   }
 
   IsoString( char_type c, size_type n = 1 )
      : string_base( c, n )
   {
   }
 
   IsoString( const_iterator i, const_iterator j )
      : string_base( i, j )
   {
   }
 
   IsoString( std::initializer_list<char_type> l )
      : IsoString( l.begin(), l.end() )
   {
   }
 
   explicit
   IsoString( const_c_ustring t )
   {
      (void)operator =( t );
   }
 
   IsoString( const_c_ustring t, size_type i, size_type n );
 
   explicit
   IsoString( const ByteArray& B )
      : IsoString( const_iterator( B.Begin() ), const_iterator( B.End() ) )
   {
   }
 
   explicit
   IsoString( bool x )
      : string_base( x ? "true" : "false" )
   {
   }
 
   explicit
   IsoString( short x )
   {
      (void)Format( "%hd", x );
   }
 
   explicit
   IsoString( unsigned short x )
   {
      (void)Format( "%hu", x );
   }
 
   explicit
   IsoString( int x )
   {
      (void)Format( "%i", x );
   }
 
   explicit
   IsoString( unsigned int x )
   {
      (void)Format( "%u", x );
   }
 
   explicit
   IsoString( long x )
   {
      (void)Format( "%ld", x );
   }
 
   explicit
   IsoString( unsigned long x )
   {
      (void)Format( "%lu", x );
   }
 
   explicit
   IsoString( long long x )
   {
      (void)Format( "%lli", x );
   }
 
   explicit
   IsoString( unsigned long long x )
   {
      (void)Format( "%llu", x );
   }
 
   explicit
   IsoString( float x )
   {
      (void)Format( "%.7g", x );
   }
 
   explicit
   IsoString( double x )
   {
      (void)Format( "%.16g", x );
   }
 
   explicit
   IsoString( long double x )
   {
#ifdef _MSC_VER
      (void)Format( "%.16Lg", x );
#else
      (void)Format( "%.18Lg", x );
#endif
   }
 
#ifndef __PCL_NO_STRING_COMPLEX
 
   explicit
   IsoString( Complex<float>& x )
   {
      (void)Format( "{%.7g,%.7g}", x.Real(), x.Imag() );
   }
 
   explicit
   IsoString( Complex<double>& x )
   {
      (void)Format( "{%.16g,%.16g}", x.Real(), x.Imag() );
   }
 
   explicit
   IsoString( Complex<long double>& x )
   {
#ifdef _MSC_VER
      (void)Format( "{%.16Lg,%.16Lg}", x.Real(), x.Imag() );
#else
      (void)Format( "{%.18Lg,%.18Lg}", x.Real(), x.Imag() );
#endif
   }
 
#endif   // !__PCL_NO_STRING_COMPLEX
 
#ifdef __PCL_QT_INTERFACE
 
   explicit
   IsoString( const QString& qs )
      : string_base( qs.isEmpty() ? iterator( nullptr ) : iterator( PCL_GET_CHARPTR_FROM_QSTRING( qs ) ) )
   {
   }
 
   explicit
   IsoString( const QAnyStringView& qv )
      : string_base( qv.isEmpty() ? iterator( nullptr ) : iterator( PCL_GET_CHARPTR_FROM_QSTRINGVIEW( qv ) ) )
   {
   }
 
   explicit
   IsoString( const QByteArray& qb )
      : string_base( qb.isEmpty() ? iterator( nullptr ) : iterator( PCL_GET_CHARPTR_FROM_QBYTEARRAY( qb ) ) )
   {
   }
 
   explicit
   IsoString( const QDate& qd )
      : string_base( iterator( PCL_GET_CHARPTR_FROM_QSTRING( qd.toString( PCL_QDATE_FMT_STR ) ) ) )
   {
   }
 
   explicit
   IsoString( const QDateTime& qdt )
      : string_base( iterator( PCL_GET_CHARPTR_FROM_QSTRING( qdt.toString( PCL_QDATETIME_FMT_STR ) ) ) )
   {
   }
 
#endif
 
   // -------------------------------------------------------------------------
 
   IsoString& operator =( const IsoString& s )
   {
      Assign( s );
      return *this;
   }
 
   IsoString& operator =( IsoString&& s )
   {
      Transfer( s );
      return *this;
   }
 
   IsoString& operator =( const string_base& s )
   {
      Assign( s );
      return *this;
   }
 
   IsoString& operator =( string_base&& s )
   {
      Transfer( s );
      return *this;
   }
 
   IsoString& operator =( const ustring_base& s )
   {
      return operator =( s.Begin() );
   }
 
   IsoString& operator =( const_c_string t )
   {
      Assign( t );
      return *this;
   }
 
   IsoString& operator =( char_type c )
   {
      Assign( c, 1 );
      return *this;
   }
 
   IsoString& operator =( const_c_ustring t );
 
#ifdef __PCL_QT_INTERFACE
 
   IsoString& operator =( const QString& qs )
   {
      if ( qs.isEmpty() )
         Clear();
      else
         Assign( PCL_GET_CHARPTR_FROM_QSTRING( qs ) );
      return *this;
   }
 
   IsoString& operator =( const QByteArray& qb )
   {
      if ( qb.isEmpty() )
         Clear();
      else
         Assign( PCL_GET_CHARPTR_FROM_QBYTEARRAY( qb ) );
      return *this;
   }
 
   IsoString& operator =( const QDate& qd )
   {
      Assign( PCL_GET_CHARPTR_FROM_QSTRING( qd.toString( PCL_QDATE_FMT_STR ) ) );
      return *this;
   }
 
   IsoString& operator =( const QDateTime& qdt )
   {
      Assign( PCL_GET_CHARPTR_FROM_QSTRING( qdt.toString( PCL_QDATETIME_FMT_STR ) ) );
      return *this;
   }
 
#endif
 
   // -------------------------------------------------------------------------
 
   IsoString SetToLength( size_type n ) const
   {
      return string_base::SetToLength( n );
   }
 
   IsoString ResizedToNullTerminated() const
   {
      return string_base::ResizedToNullTerminated();
   }
 
   IsoString Squeezed() const
   {
      return string_base::Squeezed();
   }
 
   // -------------------------------------------------------------------------
 
   IsoString Substring( size_type i, size_type n = maxPos ) const
   {
      return string_base::Substring( i, n );
   }
 
   IsoString Left( size_type n ) const
   {
      return string_base::Left( n );
   }
 
   IsoString Right( size_type n ) const
   {
      return string_base::Right( n );
   }
 
   IsoString Suffix( size_type i ) const
   {
      return string_base::Suffix( i );
   }
 
   IsoString Prefix( size_type i ) const
   {
      return string_base::Prefix( i );
   }
 
   // -------------------------------------------------------------------------
 
   IsoString Trimmed() const
   {
      return string_base::Trimmed();
   }
 
   IsoString TrimmedLeft() const
   {
      return string_base::TrimmedLeft();
   }
 
   IsoString TrimmedRight() const
   {
      return string_base::TrimmedRight();
   }
 
   // -------------------------------------------------------------------------
 
   IsoString LeftJustified( size_type width, char_type fill = IsoCharTraits::Blank() ) const
   {
      return string_base::LeftJustified( width, fill );
   }
 
   IsoString RightJustified( size_type width, char_type fill = IsoCharTraits::Blank() ) const
   {
      return string_base::RightJustified( width, fill );
   }
 
   IsoString CenterJustified( size_type width, char_type fill = IsoCharTraits::Blank() ) const
   {
      return string_base::CenterJustified( width, fill );
   }
 
   // -------------------------------------------------------------------------
 
   IsoString Enclosed( char_type c ) const
   {
      return string_base::Enclosed( c );
   }
 
   IsoString SingleQuoted() const
   {
      return string_base::SingleQuoted();
   }
 
   IsoString DoubleQuoted() const
   {
      return string_base::DoubleQuoted();
   }
 
   IsoString Unquoted() const
   {
      return string_base::Unquoted();
   }
 
   // -------------------------------------------------------------------------
 
   IsoString CaseFolded() const
   {
      return string_base::CaseFolded();
   }
 
   IsoString Lowercase() const
   {
      return string_base::Lowercase();
   }
 
   IsoString Uppercase() const
   {
      return string_base::Uppercase();
   }
 
   // -------------------------------------------------------------------------
 
   IsoString Reversed() const
   {
      return string_base::Reversed();
   }
 
   IsoString Sorted() const
   {
      return string_base::Sorted();
   }
 
   template <class BP>
   IsoString Sorted( BP p ) const
   {
      return string_base::Sorted( p );
   }
 
   // -------------------------------------------------------------------------
 
   template <class C>
   IsoString& ToSeparated( const C& c, char_type separator )
   {
      Clear();
      return c.ToSeparated( *this, separator );
   }
 
   template <class C, class AF>
   IsoString& ToSeparated( const C& c, char_type separator, AF append )
   {
      Clear();
      return c.ToSeparated( *this, separator, append );
   }
 
   template <class C>
   IsoString& ToSeparated( const C& c, const IsoString& separator )
   {
      Clear();
      return c.ToSeparated( *this, separator );
   }
 
   template <class C, class AF>
   IsoString& ToSeparated( const C& c, const IsoString& separator, AF append )
   {
      Clear();
      return c.ToSeparated( *this, separator, append );
   }
 
   template <class C>
   IsoString& ToSeparated( const C& c, const_c_string separator )
   {
      return ToSeparated( c, IsoString( separator ) );
   }
 
   template <class C, class AF>
   IsoString& ToSeparated( const C& c, const_c_string separator, AF append )
   {
      return ToSeparated( c, IsoString( separator ), append );
   }
 
   template <class C>
   IsoString& ToCommaSeparated( const C& c )
   {
      return ToSeparated( c, IsoCharTraits::Comma() );
   }
 
   template <class C>
   IsoString& ToColonSeparated( const C& c )
   {
      return ToSeparated( c, IsoCharTraits::Colon() );
   }
 
   template <class C>
   IsoString& ToSpaceSeparated( const C& c )
   {
      return ToSeparated( c, IsoCharTraits::Blank() );
   }
 
   template <class C>
   IsoString& ToTabSeparated( const C& c )
   {
      return ToSeparated( c, IsoCharTraits::Tab() );
   }
 
   template <class C>
   IsoString& ToNewLineSeparated( const C& c )
   {
      return ToSeparated( c, IsoCharTraits::LF() );
   }
 
   template <class C>
   IsoString& ToNullSeparated( const C& c )
   {
      return ToSeparated( c, IsoCharTraits::Null() );
   }
 
   template <class C>
   IsoString& ToHyphenated( const C& c )
   {
      return ToSeparated( c, IsoCharTraits::Hyphen() );
   }
 
   // -------------------------------------------------------------------------
 
   IsoString& ToEncodedHTMLSpecialChars();
 
   IsoString EncodedHTMLSpecialChars() const
   {
      return IsoString( *this ).ToEncodedHTMLSpecialChars();
   }
 
   IsoString& ToDecodedHTMLSpecialChars();
 
   IsoString DecodedHTMLSpecialChars() const
   {
      return IsoString( *this ).ToDecodedHTMLSpecialChars();
   }
 
   static IsoString ToURLEncoded( const void* data, size_type length );
 
   template <class C>
   static IsoString ToURLEncoded( const C& c )
   {
      return ToURLEncoded( c.Begin(), c.Length()*sizeof( *c.Begin() ) );
   }
 
   IsoString& ToURLEncoded();
 
   IsoString URLEncoded() const
   {
      return IsoString( *this ).ToURLEncoded();
   }
 
   static ByteArray FromURLEncoded( const void* data, size_type length );
 
   template <class C>
   static ByteArray FromURLEncoded( const C& c )
   {
      return FromURLEncoded( c.Begin(), c.Length()*sizeof( *c.Begin() ) );
   }
 
   ByteArray FromURLEncoded() const
   {
      return FromURLEncoded( Begin(), Length() );
   }
 
   static IsoString ToURLDecoded( const void* data, size_type length );
 
   template <class C>
   static IsoString ToURLDecoded( const C& c )
   {
      return ToURLDecoded( c.Begin(), c.Length()*sizeof( *c.Begin() ) );
   }
 
   IsoString& ToURLDecoded();
 
   IsoString URLDecoded() const
   {
      return IsoString( *this ).ToURLDecoded();
   }
 
   // -------------------------------------------------------------------------
 
#ifdef __PCL_QT_INTERFACE
 
   operator QString() const
   {
      return QString( c_str() );
   }
 
   operator QAnyStringView() const
   {
      return QAnyStringView( c_str() );
   }
 
   operator QByteArray() const
   {
      return QByteArray( c_str() );
   }
 
   operator QDate() const
   {
      return QDate::fromString( c_str(), PCL_QDATE_FMT_STR );
   }
 
   operator QDateTime() const
   {
      return QDateTime::fromString( c_str(), PCL_QDATETIME_FMT_STR );
   }
 
#endif
 
   IsoString& Format( const_c_string fmt, ... )
   {
      va_list paramList;
      va_start( paramList, fmt );
 
      (void)VFormat( fmt, paramList );
 
      va_end( paramList );
      return *this;
   }
 
   IsoString& AppendFormat( const_c_string fmt, ... )
   {
      va_list paramList;
      va_start( paramList, fmt );
 
      (void)AppendVFormat( fmt, paramList );
 
      va_end( paramList );
      return *this;
   }
 
   int VFormat( const_c_string fmt, va_list paramList );
 
   int AppendVFormat( const_c_string fmt, va_list paramList );
 
   // -------------------------------------------------------------------------
 
   ustring_base ToString() const
   {
      ustring_base s;
      s.SetLength( Length() );
      uchar_iterator p = s.Begin();
      for ( const_iterator i = m_data->string; i < m_data->end; ++p, ++i )
         *p = uchar_type( *i );
      return s;
   }
 
   ustring_base UTF8ToUTF16( size_type i = 0, size_type n = maxPos ) const; // implemented inline after String
 
   ustring_base MBSToWCS() const;
 
#ifdef __PCL_QT_INTERFACE
 
   QString ToQString() const
   {
      return operator QString();
   }
 
   QByteArray ToQByteArray() const
   {
      return operator QByteArray();
   }
 
   QDate ToQDate() const
   {
      return operator QDate();
   }
 
   QDateTime ToQDateTime() const
   {
      return operator QDateTime();
   }
 
#endif
 
   bool ToBool() const;
 
   bool TryToBool( bool& value ) const noexcept;
 
   float ToFloat() const;
 
   bool TryToFloat( float& value ) const noexcept;
 
   double ToDouble() const;
 
   bool TryToDouble( double& value ) const noexcept;
 
   long ToInt() const
   {
      return ToInt( 0 );
   }
 
   bool TryToInt( int& value ) const noexcept
   {
      return TryToInt( value, 0 );
   }
 
   long ToInt( int base ) const;
 
   bool TryToInt( int& value, int base ) const noexcept;
 
   unsigned long ToUInt() const
   {
      return ToUInt( 0 );
   }
 
   bool TryToUInt( unsigned& value ) const noexcept
   {
      return TryToUInt( value, 0 );
   }
 
   unsigned long ToUInt( int base ) const;
 
   bool TryToUInt( unsigned& value, int base ) const noexcept;
 
   long long ToInt64() const
   {
      return ToInt64( 0 );
   }
 
   bool TryToInt64( long long& value ) const noexcept
   {
      return TryToInt64( value, 0 );
   }
 
   long long ToInt64( int base ) const;
 
   bool TryToInt64( long long& value, int base ) const noexcept;
 
   unsigned long long ToUInt64() const
   {
      return ToUInt64( 0 );
   }
 
   bool TryToUInt64( unsigned long long& value ) const noexcept
   {
      return TryToUInt64( value, 0 );
   }
 
   unsigned long long ToUInt64( int base ) const;
 
   bool TryToUInt64( unsigned long long& value, int base ) const noexcept;
 
   Array<float> ParseListOfFloat( char separator = ',', size_type maxCount = ~size_type( 0 ) ) const;
 
   Array<double> ParseListOfDouble( char separator = ',', size_type maxCount = ~size_type( 0 ) ) const;
 
#ifndef __PCL_NO_STRING_VECTOR
 
   GenericVector<float> ParseListOfFloatAsVector( char separator = ',', int maxCount = int_max ) const;
 
   GenericVector<double> ParseListOfDoubleAsVector( char separator = ',', int maxCount = int_max ) const;
 
#endif   // !__PCL_NO_STRING_VECTOR
 
   double SexagesimalToDouble( const IsoString& separator = ':' ) const
   {
      int sign, s1, s2; double s3;
      ParseSexagesimal( sign, s1, s2, s3, separator );
      return sign*(s1 + (s2 + s3/60)/60);
   }
 
   double SexagesimalToDouble( char separator ) const
   {
      return SexagesimalToDouble( IsoString( separator ) );
   }
 
   double SexagesimalToDouble( const ustring_base& separator ) const
   {
      return SexagesimalToDouble( IsoString( separator ) );
   }
 
   double SexagesimalToDouble( const Array<char_type>& separators ) const
   {
      int sign, s1, s2; double s3;
      ParseSexagesimal( sign, s1, s2, s3, separators );
      return sign*(s1 + (s2 + s3/60)/60);
   }
 
   bool TrySexagesimalToDouble( double& value, const IsoString& separator = ':' ) const noexcept
   {
      int sign, s1, s2; double s3;
      if ( TryParseSexagesimal( sign, s1, s2, s3, separator ) )
      {
         value = sign*(s1 + (s2 + s3/60)/60);
         return true;
      }
      return false;
   }
 
   bool TrySexagesimalToDouble( double& value, char separator ) const noexcept
   {
      return TrySexagesimalToDouble( value, IsoString( separator ) );
   }
 
   bool TrySexagesimalToDouble( double& value, const ustring_base& separator ) const noexcept
   {
      return TrySexagesimalToDouble( value, IsoString( separator ) );
   }
 
   bool TrySexagesimalToDouble( double& value, const Array<char_type>& separators ) const noexcept
   {
      int sign, s1, s2; double s3;
      if ( TryParseSexagesimal( sign, s1, s2, s3, separators ) )
      {
         value = sign*(s1 + (s2 + s3/60)/60);
         return true;
      }
      return false;
   }
 
   void ParseSexagesimal( int& sign, int& s1, int& s2, double& s3, const IsoString& separator = ':' ) const;
 
   void ParseSexagesimal( int& sign, int& s1, int& s2, double& s3, char separator ) const
   {
      ParseSexagesimal( sign, s1, s2, s3, IsoString( separator ) );
   }
 
   void ParseSexagesimal( int& sign, int& s1, int& s2, double& s3, const ustring_base& separator ) const
   {
      ParseSexagesimal( sign, s1, s2, s3, IsoString( separator ) );
   }
 
   void ParseSexagesimal( int& sign, int& s1, int& s2, double& s3, const Array<char_type>& separators ) const;
 
   bool TryParseSexagesimal( int& sign, int& s1, int& s2, double& s3, const IsoString& separator = ':' ) const noexcept;
 
   bool TryParseSexagesimal( int& sign, int& s1, int& s2, double& s3, char separator ) const noexcept
   {
      return TryParseSexagesimal( sign, s1, s2, s3, IsoString( separator ) );
   }
 
   bool TryParseSexagesimal( int& sign, int& s1, int& s2, double& s3, const ustring_base& separator ) const noexcept
   {
      return TryParseSexagesimal( sign, s1, s2, s3, IsoString( separator ) );
   }
 
   bool TryParseSexagesimal( int& sign, int& s1, int& s2, double& s3, const Array<char_type>& separators ) const noexcept;
 
   static IsoString ToSexagesimal( int sign, double s1, double s2, double s3,
                                   const SexagesimalConversionOptions& options = SexagesimalConversionOptions() );
 
   static IsoString ToSexagesimal( double d, const SexagesimalConversionOptions& options = SexagesimalConversionOptions() )
   {
      return ToSexagesimal( (d < 0) ? -1 : +1, Abs( d ), 0, 0, options );
   }
 
   void ParseISO8601DateTime( int& year, int& month, int& day, double& dayf, double& tz ) const;
 
   bool TryParseISO8601DateTime( int& year, int& month, int& day, double& dayf, double& tz ) const noexcept;
 
   static IsoString ToISO8601DateTime( int year, int month, int day, double dayf, double tz = 0,
                                       const ISO8601ConversionOptions& options = ISO8601ConversionOptions() );
 
   static IsoString CurrentUTCISO8601DateTime( const ISO8601ConversionOptions& options = ISO8601ConversionOptions() );
 
   static IsoString CurrentLocalISO8601DateTime( const ISO8601ConversionOptions& options = ISO8601ConversionOptions() );
 
   static IsoString ToHex( const void* data, size_type length );
 
   template <class C>
   static IsoString ToHex( const C& c )
   {
      return ToHex( c.Begin(), c.Length()*sizeof( *c.Begin() ) );
   }
 
   static IsoString ToBase64( const void* data, size_type length );
 
   template <class C>
   static IsoString ToBase64( const C& c )
   {
      return ToBase64( c.Begin(), c.Length()*sizeof( *c.Begin() ) );
   }
 
   static IsoString ToBase64URL( const void* data, size_type length )
   {
      IsoString b64 = ToBase64( data, length );
      b64.DeleteChar( '=' );
      for ( char_type& c : b64 )
         if ( c == '+' )
            c = '-';
         else if ( c == '/' )
            c = '_';
      return b64;
   }
 
   template <class C>
   static IsoString ToBase64URL( const C& c )
   {
      return ToBase64URL( c.Begin(), c.Length()*sizeof( *c.Begin() ) );
   }
 
   ByteArray ToByteArray() const
   {
      return ByteArray( Begin(), End() );
   }
 
   ByteArray FromHex() const;
 
   ByteArray FromBase64() const;
 
   ByteArray FromBase64URL() const
   {
      IsoString b64 = *this;
      for ( char_type& c : b64 )
         if ( c == '-' )
            c = '+';
         else if ( c == '_' )
            c = '/';
      return b64.FromBase64();
   }
 
   static IsoString Random( size_type n, RandomizationOptions options = RandomizationOption::Default );
 
   static IsoString UUID();
};
 
// ----------------------------------------------------------------------------
 
inline IsoString operator +( const IsoString::string_base& s1, const IsoString::string_base& s2 )
{
   IsoString s( s1 );
   s.Append( s2 );
   return s;
}
 
inline IsoString operator +( IsoString::string_base&& s1, const IsoString::string_base& s2 )
{
   s1.Append( s2 );
   return IsoString( std::move( s1 ) );
}
 
inline IsoString operator +( IsoString&& s1, const IsoString::string_base& s2 )
{
   s1.Append( s2 );
   return std::move( s1 );
}
 
inline IsoString operator +( const IsoString::string_base& s1, IsoString::string_base&& s2 )
{
   s2.Prepend( s1 );
   return IsoString( std::move( s2 ) );
}
 
inline IsoString operator +( const IsoString::string_base& s1, IsoString&& s2 )
{
   s2.Prepend( s1 );
   return std::move( s2 );
}
 
inline IsoString operator +( IsoString::string_base&& s1, IsoString::string_base&& s2 )
{
   s1.Append( s2 );
   return IsoString( std::move( s1 ) );
}
 
inline IsoString operator +( IsoString&& s1, IsoString::string_base&& s2 )
{
   s1.Append( s2 );
   return std::move( s1 );
}
 
inline IsoString operator +( IsoString::string_base&& s1, IsoString&& s2 )
{
   s1.Append( s2 );
   return IsoString( std::move( s1 ) );
}
 
inline IsoString operator +( IsoString&& s1, IsoString&& s2 )
{
   s1.Append( s2 );
   return std::move( s1 );
}
 
// ----------------------------------------------------------------------------
 
inline IsoString operator +( const IsoString::string_base& s1, IsoString::const_c_string t2 )
{
   IsoString s = s1;
   s.Append( t2 );
   return s;
}
 
inline IsoString operator +( IsoString::string_base&& s1, IsoString::const_c_string t2 )
{
   s1.Append( t2 );
   return IsoString( std::move( s1 ) );
}
 
inline IsoString operator +( IsoString&& s1, IsoString::const_c_string t2 )
{
   s1.Append( t2 );
   return std::move( s1 );
}
 
inline IsoString operator +( IsoString::const_c_string t1, const IsoString::string_base& s2 )
{
   IsoString s = s2;
   s.Prepend( t1 );
   return s;
}
 
inline IsoString operator +( IsoString::const_c_string t1, IsoString::string_base&& s2 )
{
   s2.Prepend( t1 );
   return IsoString( std::move( s2 ) );
}
 
inline IsoString operator +( IsoString::const_c_string t1, IsoString&& s2 )
{
   s2.Prepend( t1 );
   return std::move( s2 );
}
 
// ----------------------------------------------------------------------------
 
inline IsoString operator +( const IsoString::string_base& s1, IsoString::char_type c2 )
{
   IsoString s = s1;
   s.Append( c2 );
   return s;
}
 
inline IsoString operator +( IsoString::string_base&& s1, IsoString::char_type c2 )
{
   s1.Append( c2 );
   return IsoString( std::move( s1 ) );
}
 
inline IsoString operator +( IsoString&& s1, IsoString::char_type c2 )
{
   s1.Append( c2 );
   return std::move( s1 );
}
 
inline IsoString operator +( IsoString::char_type c1, const IsoString::string_base& s2 )
{
   IsoString s = s2;
   s.Prepend( c1 );
   return s;
}
 
inline IsoString operator +( IsoString::char_type c1, IsoString::string_base&& s2 )
{
   s2.Prepend( c1 );
   return IsoString( std::move( s2 ) );
}
 
inline IsoString operator +( IsoString::char_type c1, IsoString&& s2 )
{
   s2.Prepend( c1 );
   return std::move( s2 );
}
 
// ----------------------------------------------------------------------------
 
inline IsoString& operator <<( IsoString& s1, const IsoString::string_base& s2 )
{
   s1.Append( s2 );
   return s1;
}
 
inline IsoString& operator <<( IsoString&& s1, const IsoString::string_base& s2 )
{
   s1.Append( s2 );
   return s1;
}
 
inline IsoString& operator <<( IsoString& s1, IsoString::const_c_string t2 )
{
   s1.Append( t2 );
   return s1;
}
 
inline IsoString& operator <<( IsoString&& s1, IsoString::const_c_string t2 )
{
   s1.Append( t2 );
   return s1;
}
 
inline IsoString& operator <<( IsoString& s1, IsoString::char_type c2 )
{
   s1.Append( c2 );
   return s1;
}
 
inline IsoString& operator <<( IsoString&& s1, IsoString::char_type c2 )
{
   s1.Append( c2 );
   return s1;
}
 
// ----------------------------------------------------------------------------
 
#ifndef __PCL_NO_STRING_OSTREAM
 
inline std::ostream& operator <<( std::ostream& o, const IsoString& s )
{
   return o << s.c_str();
}
 
#endif
 
// ----------------------------------------------------------------------------
 
class PCL_CLASS String : public GenericString<char16_type, CharTraits, PCL_STRING_ALLOCATOR>
{
public:
 
   using string_base = GenericString<char16_type, CharTraits, PCL_STRING_ALLOCATOR>;
 
   using char_type = string_base::char_type;
 
   using char_traits = string_base::char_traits;
 
   using block_allocator = string_base::block_allocator;
 
   using allocator = string_base::allocator;
 
   using c_string = string_base::c_string;
 
   using const_c_string = string_base::const_c_string;
 
   /*
    * Null-terminated UTF-16 string - C++11 compatibility.
    */
   using c16_string = char16_t*;
 
   /*
    * Immutable null-terminated UTF-16 string - C++11 compatibility.
    */
   using const_c16_string = const char16_t*;
 
   using iterator = string_base::iterator;
 
   using const_iterator = string_base::const_iterator;
 
   using reverse_iterator = string_base::reverse_iterator;
 
   using const_reverse_iterator = string_base::const_reverse_iterator;
 
   using string8_base = GenericString<char, IsoCharTraits, PCL_STRING_ALLOCATOR>;
 
   using char8_type = string8_base::char_type;
 
   using char8_traits = string8_base::char_traits;
 
   using c_string8 = string8_base::c_string;
 
   using const_c_string8 = string8_base::const_c_string;
 
   using char8_iterator = string8_base::iterator;
 
   using const_char8_iterator = string8_base::const_iterator;
 
   // -------------------------------------------------------------------------
 
   String() = default;
 
   String( const string_base& s )
      : string_base( s )
   {
   }
 
   String( const String& ) = default;
 
   String( string_base&& s )
      : string_base( std::move( s ) )
   {
   }
 
   String( String&& ) = default;
 
   String( const string8_base& s )
   {
      Assign( s );
   }
 
   String( const_iterator t )
      : string_base( t )
   {
   }
 
   String( const_iterator t, size_type i, size_type n )
      : string_base( t, i, n )
   {
   }
 
   String( char_type c, size_type n )
      : string_base( c, n )
   {
   }
 
   String( const_iterator i, const_iterator j )
      : string_base( i, j )
   {
   }
 
   String( std::initializer_list<char_type> l )
      : String( l.begin(), l.end() )
   {
   }
 
   String( const char16_t* t )
      : string_base( reinterpret_cast<const_iterator>( t ) )
   {
   }
 
   String( const char16_t* t, size_type i, size_type n )
      : string_base( reinterpret_cast<const_iterator>( t ), i, n )
   {
   }
 
   String( char16_t c, size_type n )
      : string_base( char_type( c ), n )
   {
   }
 
   String( const wchar_t* t )
   {
      Assign( t );
   }
 
   String( const wchar_t* t, size_type i, size_type n )
   {
      Assign( t, i, n );
   }
 
   String( wchar_t c, size_type n )
      : string_base( char_type( c ), n )
   {
   }
 
   String( const_c_string8 t )
   {
      Assign( t );
   }
 
   String( const_c_string8 t, size_type i, size_type n )
   {
      Assign( t, i, n );
   }
 
   String( const_char8_iterator i, const_char8_iterator j )
   {
      Assign( i, j );
   }
 
   String( std::initializer_list<char8_type> l )
      : String( l.begin(), l.end() )
   {
   }
 
   String( char8_type c, size_type n = 1 )
      : string_base( char_type( c ), n )
   {
   }
 
   explicit
   String( bool x )
   {
      Assign( x ? "true" : "false" );
   }
 
   explicit
   String( short x )
   {
      (void)Format( L"%hd", x );
   }
 
   explicit
   String( unsigned short x )
   {
      (void)Format( L"%hu", x );
   }
 
   explicit
   String( int x )
   {
      (void)Format( L"%i", x );
   }
 
   explicit
   String( unsigned int x )
   {
      (void)Format( L"%u", x );
   }
 
   explicit
   String( long x )
   {
      (void)Format( L"%ld", x );
   }
 
   explicit
   String( unsigned long x )
   {
      (void)Format( L"%lu", x );
   }
 
   explicit
   String( long long x )
   {
      (void)Format( L"%lli", x );
   }
 
   explicit
   String( unsigned long long x )
   {
      (void)Format( L"%llu", x );
   }
 
   explicit
   String( float x )
   {
      (void)Format( L"%.7g", x );
   }
 
   explicit
   String( double x )
   {
      (void)Format( L"%.16g", x );
   }
 
   explicit
   String( long double x )
   {
#ifdef _MSC_VER
      (void)Format( L"%.16Lg", x );
#else
      (void)Format( L"%.18Lg", x );
#endif
   }
 
#ifndef __PCL_NO_STRING_COMPLEX
 
   explicit
   String( Complex<float>& x )
   {
      (void)Format( L"{%.7g,%.7g}", x.Real(), x.Imag() );
   }
 
   explicit
   String( Complex<double>& x )
   {
      (void)Format( L"{%.16g,%.16g}", x.Real(), x.Imag() );
   }
 
   explicit
   String( Complex<long double>& x )
   {
#ifdef _MSC_VER
      (void)Format( L"{%.16Lg,%.16Lg}", x.Real(), x.Imag() );
#else
      (void)Format( L"{%.18Lg,%.18Lg}", x.Real(), x.Imag() );
#endif
   }
 
#endif   // !__PCL_NO_STRING_COMPLEX
 
#ifdef __PCL_QT_INTERFACE
 
   explicit
   String( const QString& qs )
      : string_base( qs.isEmpty() ? iterator( nullptr ) : iterator( PCL_GET_CHAR16PTR_FROM_QSTRING( qs ) ) )
   {
   }
 
   explicit
   String( const QDate& qd )
      : string_base( iterator( PCL_GET_CHAR16PTR_FROM_QSTRING( qd.toString( PCL_QDATE_FMT_STR ) ) ) )
   {
   }
 
   explicit
   String( const QDateTime& qdt )
      : string_base( iterator( PCL_GET_CHAR16PTR_FROM_QSTRING( qdt.toString( PCL_QDATETIME_FMT_STR ) ) ) )
   {
   }
 
#endif
 
   // -------------------------------------------------------------------------
 
   String& operator =( const String& s )
   {
      string_base::Assign( s );
      return *this;
   }
 
   String& operator =( String&& s )
   {
      string_base::Transfer( s );
      return *this;
   }
 
   String& operator =( const string_base& s )
   {
      string_base::Assign( s );
      return *this;
   }
 
   String& operator =( string_base&& s )
   {
      string_base::Transfer( s );
      return *this;
   }
 
   String& operator =( const string8_base& s )
   {
      Assign( s );
      return *this;
   }
 
   String& operator =( const_iterator t )
   {
      string_base::Assign( t );
      return *this;
   }
 
   String& operator =( char_type c )
   {
      string_base::Assign( c );
      return *this;
   }
 
   String& operator =( const char16_t* t )
   {
      string_base::Assign( reinterpret_cast<const_iterator>( t ) );
      return *this;
   }
 
   String& operator =( char16_t c )
   {
      string_base::Assign( char_type( c ) );
      return *this;
   }
 
   String& operator =( const wchar_t* t )
   {
      Assign( t );
      return *this;
   }
 
   String& operator =( wchar_t c )
   {
      Assign( c );
      return *this;
   }
 
   String& operator =( const_c_string8 t )
   {
      Assign( t );
      return *this;
   }
 
   String& operator =( char8_type c )
   {
      Assign( c );
      return *this;
   }
 
#ifdef __PCL_QT_INTERFACE
 
   String& operator =( const QString& qs )
   {
      if ( qs.isEmpty() )
         Clear();
      else
         string_base::Assign( PCL_GET_CHAR16PTR_FROM_QSTRING( qs ) );
      return *this;
   }
 
   String& operator =( const QDate& qd )
   {
      string_base::Assign( PCL_GET_CHAR16PTR_FROM_QSTRING( qd.toString( PCL_QDATE_FMT_STR ) ) );
      return *this;
   }
 
   String& operator =( const QDateTime& qdt )
   {
      string_base::Assign( PCL_GET_CHAR16PTR_FROM_QSTRING( qdt.toString( PCL_QDATETIME_FMT_STR ) ) );
      return *this;
   }
 
#endif
 
   // -------------------------------------------------------------------------
 
   void Assign( const String& s )
   {
      string_base::Assign( s );
   }
 
   void Assign( const String& s, size_type i, size_type n )
   {
      string_base::Assign( s, i, n );
   }
 
   void Assign( const_iterator t )
   {
      string_base::Assign( t );
   }
 
   void Assign( const_iterator i, const_iterator j )
   {
      string_base::Assign( i, j );
   }
 
   void Assign( std::initializer_list<char_type> l )
   {
      Assign( l.begin(), l.end() );
   }
 
   void Assign( const_iterator t, size_type i, size_type n )
   {
      string_base::Assign( t, i, n );
   }
 
   void Assign( char_type c, size_type n = 1 )
   {
      string_base::Assign( c, n );
   }
 
   void Assign( const char16_t* t )
   {
      string_base::Assign( reinterpret_cast<const_iterator>( t ) );
   }
 
   void Assign( const char16_t* t, size_type i, size_type n )
   {
      string_base::Assign( reinterpret_cast<const_iterator>( t ), i, n );
   }
 
   void Assign( char16_t c, size_type n = 1 )
   {
      string_base::Assign( char_type( c ), n );
   }
 
   void Assign( const wchar_t* t );
 
   void Assign( const wchar_t* t, size_type i, size_type n );
 
   void Assign( wchar_t c, size_type n = 1 )
   {
      string_base::Assign( char_type( c ), n );
   }
 
   void Assign( const string8_base& s )
   {
      size_type n = s.Length();
      if ( n > 0 )
      {
         MaybeReallocate( n );
         const_char8_iterator t = s.Begin();
         PCL_IVDEP
         for ( iterator i = m_data->string; i < m_data->end; ++i, ++t )
            *i = char_type( uint8( *t ) );
      }
      else
         Clear();
   }
 
   void Assign( const_c_string8 t )
   {
      size_type n = char8_traits::Length( t );
      if ( n > 0 )
      {
         MaybeReallocate( n );
         PCL_IVDEP
         for ( iterator i = m_data->string; i < m_data->end; ++i, ++t )
            *i = char_type( uint8( *t ) );
      }
      else
         Clear();
   }
 
   void Assign( const_c_string8 t, size_type i, size_type n )
   {
      size_type len = char8_traits::Length( t );
      if ( i < len )
      {
         n = pcl::Min( n, len-i );
         MaybeReallocate( n );
         t += i;
         PCL_IVDEP
         for ( iterator i = m_data->string; i < m_data->end; ++i, ++t )
            *i = char_type( uint8( *t ) );
      }
      else
         Clear();
   }
 
   void Assign( const_char8_iterator p, const_char8_iterator q )
   {
      if ( p < q )
      {
         MaybeReallocate( q - p );
         PCL_IVDEP
         for ( iterator i = m_data->string; i < m_data->end; ++i, ++p )
            *i = char_type( uint8( *p ) );
      }
      else
         Clear();
   }
 
   void Assign( std::initializer_list<char8_type> l )
   {
      Assign( l.begin(), l.end() );
   }
 
   void Assign( char8_type c, size_type n = 1 )
   {
      string_base::Assign( char_type( c ), n );
   }
 
   // -------------------------------------------------------------------------
 
   void Insert( size_type i, const String& s )
   {
      string_base::Insert( i, s );
   }
 
   void Insert( size_type i, const_iterator p, const_iterator q )
   {
      string_base::Insert( i, p, q );
   }
 
   void Insert( size_type i, const_iterator t )
   {
      string_base::Insert( i, t );
   }
 
   void Insert( size_type i, const_iterator t, size_type n )
   {
      string_base::Insert( i, t, n );
   }
 
   void Insert( size_type i, char_type c, size_type n = 1 )
   {
      string_base::Insert( i, c, n );
   }
 
   void Insert( size_type i, const char16_t* t )
   {
      string_base::Insert( i, reinterpret_cast<const_iterator>( t ) );
   }
 
   void Insert( size_type i, char16_t c, size_type n = 1 )
   {
      string_base::Insert( i, String( c, n ) );
   }
 
   void Insert( size_type i, const wchar_t* t )
   {
#ifdef __PCL_WINDOWS
      string_base::Insert( i, reinterpret_cast<const_iterator>( t ) );
#else
      string_base::Insert( i, String( t ) );
#endif
   }
 
   void Insert( size_type i, wchar_t c, size_type n = 1 )
   {
      string_base::Insert( i, String( c, n ) );
   }
 
   void Insert( size_type i, const string8_base& s, size_type n )
   {
      n = pcl::Min( n, s.Length() );
      if ( n > 0 )
      {
         UninitializedGrow( i, n ); // -> 0 <= i <= len
         const_char8_iterator t = s.Begin();
         PCL_IVDEP
         for ( iterator p = m_data->string+i, q = p+n; p < q; ++p, ++t )
            *p = char_type( uint8( *t ) );
      }
   }
 
   void Insert( size_type i, const string8_base& s )
   {
      size_type n = s.Length();
      if ( n > 0 )
      {
         UninitializedGrow( i, n ); // -> 0 <= i <= len
         const_char8_iterator t = s.Begin();
         PCL_IVDEP
         for ( iterator p = m_data->string+i, q = p+n; p < q; ++p, ++t )
            *p = char_type( uint8( *t ) );
      }
   }
 
   void Insert( size_type i, const_c_string8 t )
   {
      size_type n = char8_traits::Length( t );
      if ( n > 0 )
      {
         UninitializedGrow( i, n ); // -> 0 <= i <= len
         PCL_IVDEP
         for ( iterator p = m_data->string+i, q = p+n; p < q; ++p, ++t )
            *p = char_type( uint8( *t ) );
      }
   }
 
   void Insert( size_type i, const_c_string8 t, size_type n )
   {
      n = pcl::Min( n, char8_traits::Length( t ) );
      if ( n > 0 )
      {
         UninitializedGrow( i, n ); // -> 0 <= i <= len
         PCL_IVDEP
         for ( iterator p = m_data->string+i, q = p+n; p < q; ++p, ++t )
            *p = char_type( uint8( *t ) );
      }
   }
 
   void Insert( size_type i, const_char8_iterator p, const_char8_iterator q )
   {
      if ( p < q )
      {
         size_type n = q - p;
         UninitializedGrow( i, n ); // -> 0 <= i <= len
         PCL_IVDEP
         for ( iterator r = m_data->string+i, s = r+n; r < s; ++r, ++p )
            *r = char_type( uint8( *p ) );
      }
   }
 
   void Insert( size_type i, char8_type c, size_type n = 1 )
   {
      string_base::Insert( i, char_type( c ), n );
   }
 
   // -------------------------------------------------------------------------
 
   void Append( const String& s )
   {
      string_base::Append( s );
   }
 
   String& operator +=( const String& s )
   {
      Append( s );
      return *this;
   }
 
   void Append( const_iterator i, const_iterator j )
   {
      string_base::Append( i, j );
   }
 
   void Append( const_iterator t )
   {
      string_base::Append( t );
   }
 
   String& operator +=( const_iterator t )
   {
      Append( t );
      return *this;
   }
 
   void Append( const_iterator t, size_type n )
   {
      string_base::Append( t, n );
   }
 
   void Append( char_type c, size_type n = 1 )
   {
      string_base::Append( c, n );
   }
 
   String& operator +=( char_type c )
   {
      Append( c );
      return *this;
   }
 
   void Append( const char16_t* t )
   {
      string_base::Append( reinterpret_cast<const_iterator>( t ) );
   }
 
   String& operator +=( const char16_t* t )
   {
      Append( t );
      return *this;
   }
 
   void Append( char16_t c, size_type n = 1 )
   {
      string_base::Append( char_type( c ), n );
   }
 
   String& operator +=( char16_t c )
   {
      Append( c );
      return *this;
   }
 
   void Append( const wchar_t* t )
   {
#ifdef __PCL_WINDOWS
      string_base::Append( reinterpret_cast<const_iterator>( t ) );
#else
      string_base::Append( String( t ) );
#endif
   }
 
   String& operator +=( const wchar_t* t )
   {
      Append( t );
      return *this;
   }
 
   void Append( wchar_t c, size_type n = 1 )
   {
      string_base::Append( char_type( c ), n );
   }
 
   String& operator +=( wchar_t c )
   {
      Append( c );
      return *this;
   }
 
   void Append( const string8_base& s )
   {
      Insert( maxPos, s );
   }
 
   String& operator +=( const string8_base& s )
   {
      Append( s );
      return *this;
   }
 
   void Append( const string8_base& s, size_type n )
   {
      Insert( maxPos, s, n );
   }
 
   void Append( const_c_string8 t )
   {
      Insert( maxPos, t );
   }
 
   String& operator +=( const_c_string8 t )
   {
      Append( t );
      return *this;
   }
 
   void Append( const_c_string8 t, size_type n )
   {
      Insert( maxPos, t, n );
   }
 
   void Append( const_char8_iterator p, const_char8_iterator q )
   {
      Insert( maxPos, p, q );
   }
 
   void Append( char8_type c, size_type n = 1 )
   {
      string_base::Append( char_type( c ), n );
   }
 
   String& operator +=( char8_type c )
   {
      Append( c );
      return *this;
   }
 
   void Add( const String& s )
   {
      Append( s );
   }
 
   void Add( const_iterator i, const_iterator j )
   {
      Append( i, j );
   }
 
   void Add( const_iterator t )
   {
      Append( t );
   }
 
   void Add( const_iterator t, size_type n )
   {
      Append( t, n );
   }
 
   void Add( char_type c, size_type n = 1 )
   {
      Append( c, n );
   }
 
   void Add( const char16_t* t )
   {
      Append( t );
   }
 
   void Add( char16_t c, size_type n = 1 )
   {
      Append( c, n );
   }
 
   void Add( const wchar_t* t )
   {
      Append( t );
   }
 
   void Add( wchar_t c, size_type n = 1 )
   {
      Append( c, n );
   }
 
   void Add( const string8_base& s )
   {
      Append( s );
   }
 
   void Add( const string8_base& s, size_type n )
   {
      Append( s, n );
   }
 
   void Add( const_c_string8 t )
   {
      Append( t );
   }
 
   void Add( const_c_string8 t, size_type n )
   {
      Append( t, n );
   }
 
   void Add( const_char8_iterator p, const_char8_iterator q )
   {
      Append( p, q );
   }
 
   void Add( char8_type c, size_type n = 1 )
   {
      Append( c, n );
   }
 
   // -------------------------------------------------------------------------
 
   void Prepend( const String& s )
   {
      string_base::Prepend( s );
   }
 
   String& operator -=( const String& s )
   {
      Prepend( s );
      return *this;
   }
 
   void Prepend( const_iterator i, const_iterator j )
   {
      string_base::Prepend( i, j );
   }
 
   void Prepend( const_iterator t )
   {
      string_base::Prepend( t );
   }
 
   String& operator -=( const_iterator t )
   {
      Prepend( t );
      return *this;
   }
 
   void Prepend( const_iterator t, size_type n )
   {
      string_base::Prepend( t, n );
   }
 
   void Prepend( char_type c, size_type n = 1 )
   {
      string_base::Prepend( c, n );
   }
 
   String& operator -=( char_type c )
   {
      Prepend( c );
      return *this;
   }
 
   void Prepend( const char16_t* t )
   {
      string_base::Prepend( reinterpret_cast<const_iterator>( t ) );
   }
 
   String& operator -=( const char16_t* t )
   {
      Prepend( t );
      return *this;
   }
 
   void Prepend( char16_t c, size_type n = 1 )
   {
      string_base::Prepend( char_type( c ), n );
   }
 
   String& operator -=( char16_t c )
   {
      Prepend( c );
      return *this;
   }
 
   void Prepend( const wchar_t* t )
   {
#ifdef __PCL_WINDOWS
      string_base::Prepend( reinterpret_cast<const_iterator>( t ) );
#else
      string_base::Prepend( String( t ) );
#endif
   }
 
   String& operator -=( const wchar_t* t )
   {
      Prepend( t );
      return *this;
   }
 
   void Prepend( wchar_t c, size_type n = 1 )
   {
      string_base::Prepend( char_type( c ), n );
   }
 
   String& operator -=( wchar_t c )
   {
      Prepend( c );
      return *this;
   }
 
   void Prepend( const string8_base& s )
   {
      Insert( 0, s );
   }
 
   String& operator -=( const string8_base& s )
   {
      Prepend( s );
      return *this;
   }
 
   void Prepend( const string8_base& s, size_type n )
   {
      Insert( 0, s, n );
   }
 
   void Prepend( const_c_string8 t )
   {
      Insert( 0, t );
   }
 
   String& operator -=( const_c_string8 t )
   {
      Prepend( t );
      return *this;
   }
 
   void Prepend( const_c_string8 t, size_type n )
   {
      Insert( 0, t, n );
   }
 
   void Prepend( const_char8_iterator p, const_char8_iterator q )
   {
      Insert( 0, p, q );
   }
 
   void Prepend( char8_type c, size_type n = 1 )
   {
      string_base::Prepend( String( c, n ) );
   }
 
   String& operator -=( char8_type c )
   {
      Prepend( c );
      return *this;
   }
 
   // -------------------------------------------------------------------------
 
   void Replace( size_type i, size_type n, const String& s )
   {
      string_base::Replace( i, n, s );
   }
 
   void Replace( size_type i, size_type n, const_iterator t )
   {
      string_base::Replace( i, n, t );
   }
 
   void Replace( size_type i, size_type n, char_type c, size_type nc = 1 )
   {
      string_base::Replace( i, n, c, nc );
   }
 
   void Replace( size_type i, size_type n, const char16_t* t )
   {
      string_base::Replace( i, n, reinterpret_cast<const_iterator>( t ) );
   }
 
   void Replace( size_type i, size_type n, char16_t c, size_type nc = 1 )
   {
      string_base::Replace( i, n, char_type( c ), nc );
   }
 
   void Replace( size_type i, size_type n, const wchar_t* t )
   {
#ifdef __PCL_WINDOWS
      string_base::Replace( i, n, reinterpret_cast<const_iterator>( t ) );
#else
      string_base::Replace( i, n, String( t ) );
#endif
   }
 
   void Replace( size_type i, size_type n, wchar_t c, size_type nc = 1 )
   {
      string_base::Replace( i, n, char_type( c ), nc );
   }
 
   void Replace( size_type i, size_type n, const_c_string8 t )
   {
      if ( n > 0 )
      {
         size_type len = Length();
         if ( i < len )
         {
            n = pcl::Min( n, len-i );
            if ( n == len )
               Assign( t );
            else
            {
               size_type nt = char8_traits::Length( t );
               if ( nt > 0 )
               {
                  if ( n < nt )
                     UninitializedGrow( i, nt-n );
                  else if ( nt < n )
                     Delete( i, n-nt );
                  else
                     EnsureUnique();
 
                  PCL_IVDEP
                  for ( iterator p = m_data->string+i, q = p+nt; p < q; ++p, ++t )
                     *p = char_type( *t );
               }
               else
                  Delete( i, n );
            }
         }
      }
   }
 
   void Replace( size_type i, size_type n, char8_type c, size_type nc = 1 )
   {
      string_base::Replace( i, n, char_type( c ), nc );
   }
 
   // -------------------------------------------------------------------------
 
   void ReplaceChar( char_type c1, char_type c2, size_type i = 0, size_type n = maxPos )
   {
      string_base::ReplaceChar( c1, c2, i, n );
   }
 
   void ReplaceCharIC( char_type c1, char_type c2, size_type i = 0, size_type n = maxPos )
   {
      string_base::ReplaceCharIC( c1, c2, i, n );
   }
 
   void ReplaceChar( char16_t c1, char16_t c2, size_type i = 0, size_type n = maxPos )
   {
      string_base::ReplaceChar( char_type( c1 ), char_type( c2 ), i, n );
   }
 
   void ReplaceCharIC( char16_t c1, char16_t c2, size_type i = 0, size_type n = maxPos )
   {
      string_base::ReplaceCharIC( char_type( c1 ), char_type( c2 ), i, n );
   }
 
   void ReplaceChar( wchar_t c1, wchar_t c2, size_type i = 0, size_type n = maxPos )
   {
      string_base::ReplaceChar( char_type( c1 ), char_type( c2 ), i, n );
   }
 
   void ReplaceCharIC( wchar_t c1, wchar_t c2, size_type i = 0, size_type n = maxPos )
   {
      string_base::ReplaceCharIC( char_type( c1 ), char_type( c2 ), i, n );
   }
 
   void ReplaceChar( char8_type c1, char8_type c2, size_type i = 0, size_type n = maxPos )
   {
      string_base::ReplaceChar( char_type( c1 ), char_type( c2 ), i, n );
   }
 
   void ReplaceCharIC( char8_type c1, char8_type c2, size_type i = 0, size_type n = maxPos )
   {
      string_base::ReplaceCharIC( char_type( c1 ), char_type( c2 ), i, n );
   }
 
   // -------------------------------------------------------------------------
 
   void ReplaceString( const String& s1, const String& s2, size_type i = 0 )
   {
      string_base::ReplaceString( s1, s2, i );
   }
 
   void ReplaceStringIC( const String& s1, const String& s2, size_type i = 0 )
   {
      string_base::ReplaceStringIC( s1, s2, i );
   }
 
   void ReplaceString( const_iterator t1, const_iterator t2, size_type i = 0 )
   {
      string_base::ReplaceString( t1, t2, i );
   }
 
   void ReplaceStringIC( const_iterator t1, const_iterator t2, size_type i = 0 )
   {
      string_base::ReplaceStringIC( t1, t2, i );
   }
 
   void ReplaceString( const char16_t* t1, const char16_t* t2, size_type i = 0 )
   {
      string_base::ReplaceString( reinterpret_cast<const_iterator>( t1 ),
                                  reinterpret_cast<const_iterator>( t2 ), i );
   }
 
   void ReplaceStringIC( const char16_t* t1, const char16_t* t2, size_type i = 0 )
   {
      string_base::ReplaceStringIC( reinterpret_cast<const_iterator>( t1 ),
                                    reinterpret_cast<const_iterator>( t2 ), i );
   }
 
   void ReplaceString( const wchar_t* t1, const wchar_t* t2, size_type i = 0 )
   {
#ifdef __PCL_WINDOWS
      string_base::ReplaceString( reinterpret_cast<const_iterator>( t1 ),
                                  reinterpret_cast<const_iterator>( t2 ), i );
#else
      string_base::ReplaceString( String( t1 ), String( t2 ), i );
#endif
   }
 
   void ReplaceStringIC( const wchar_t* t1, const wchar_t* t2, size_type i = 0 )
   {
#ifdef __PCL_WINDOWS
      string_base::ReplaceStringIC( reinterpret_cast<const_iterator>( t1 ),
                                    reinterpret_cast<const_iterator>( t2 ), i );
#else
      string_base::ReplaceStringIC( String( t1 ), String( t2 ), i );
#endif
   }
 
   void ReplaceString( const_c_string8 t1, const_c_string8 t2, size_type i = 0 )
   {
      string_base::ReplaceString( String( t1 ), String( t2 ), i );
   }
 
   void ReplaceStringIC( const_c_string8 t1, const_c_string8 t2, size_type i = 0 )
   {
      string_base::ReplaceStringIC( String( t1 ), String( t2 ), i );
   }
 
   // -------------------------------------------------------------------------
 
   void DeleteChar( char_type c, size_type i = 0 )
   {
      string_base::DeleteChar( c, i );
   }
 
   void DeleteCharIC( char_type c, size_type i = 0 )
   {
      string_base::DeleteCharIC( c, i );
   }
 
   void DeleteChar( char16_t c, size_type i = 0 )
   {
      string_base::DeleteChar( char_type( c ), i );
   }
 
   void DeleteCharIC( char16_t c, size_type i = 0 )
   {
      string_base::DeleteCharIC( char_type( c ), i );
   }
 
   void DeleteChar( wchar_t c, size_type i = 0 )
   {
      string_base::DeleteChar( char_type( c ), i );
   }
 
   void DeleteCharIC( wchar_t c, size_type i = 0 )
   {
      string_base::DeleteCharIC( char_type( c ), i );
   }
 
   void DeleteChar( char8_type c, size_type i = 0 )
   {
      string_base::DeleteChar( char_type( c ), i );
   }
 
   void DeleteCharIC( char8_type c, size_type i = 0 )
   {
      string_base::DeleteCharIC( char_type( c ), i );
   }
 
   // -------------------------------------------------------------------------
 
   void DeleteString( const String& s, size_type i = 0 )
   {
      string_base::DeleteString( s, i );
   }
 
   void DeleteStringIC( const String& s, size_type i = 0 )
   {
      string_base::DeleteStringIC( s, i );
   }
 
   void DeleteString( const_iterator t, size_type i = 0 )
   {
      string_base::DeleteString( t, i );
   }
 
   void DeleteStringIC( const_iterator t, size_type i = 0 )
   {
      string_base::DeleteStringIC( t, i );
   }
 
   void DeleteString( const char16_t* t, size_type i = 0 )
   {
      string_base::DeleteString( reinterpret_cast<const_iterator>( t ), i );
   }
 
   void DeleteStringIC( const char16_t* t, size_type i = 0 )
   {
      string_base::DeleteStringIC( reinterpret_cast<const_iterator>( t ), i );
   }
 
   void DeleteString( const wchar_t* t, size_type i = 0 )
   {
#ifdef __PCL_WINDOWS
      string_base::DeleteString( reinterpret_cast<const_iterator>( t ), i );
#else
      string_base::DeleteString( String( t ), i );
#endif
   }
 
   void DeleteStringIC( const wchar_t* t, size_type i = 0 )
   {
#ifdef __PCL_WINDOWS
      string_base::DeleteStringIC( reinterpret_cast<const_iterator>( t ), i );
#else
      string_base::DeleteStringIC( String( t ), i );
#endif
   }
 
   void DeleteString( const_c_string8 t, size_type i = 0 )
   {
      string_base::DeleteString( String( t ), i );
   }
 
   void DeleteStringIC( const_c_string8 t, size_type i = 0 )
   {
      string_base::DeleteStringIC( String( t ), i );
   }
 
   // -------------------------------------------------------------------------
 
   bool StartsWith( const String& s ) const noexcept
   {
      return string_base::StartsWith( s );
   }
 
   bool StartsWith( const_iterator t ) const noexcept
   {
      return string_base::StartsWith( t );
   }
 
   bool StartsWith( char_type c ) const noexcept
   {
      return string_base::StartsWith( c );
   }
 
   bool StartsWithIC( const String& s ) const noexcept
   {
      return string_base::StartsWithIC( s );
   }
 
   bool StartsWithIC( const_iterator t ) const noexcept
   {
      return string_base::StartsWithIC( t );
   }
 
   bool StartsWithIC( char_type c ) const noexcept
   {
      return string_base::StartsWithIC( c );
   }
 
   bool StartsWith( const char16_t* t ) const noexcept
   {
      return string_base::StartsWith( reinterpret_cast<const_iterator>( t ) );
   }
 
   bool StartsWith( char16_t c ) const noexcept
   {
      return string_base::StartsWith( char_type( c ) );
   }
 
   bool StartsWithIC( const char16_t* t ) const noexcept
   {
      return string_base::StartsWithIC( reinterpret_cast<const_iterator>( t ) );
   }
 
   bool StartsWithIC( char16_t c ) const noexcept
   {
      return string_base::StartsWithIC( char_type( c ) );
   }
 
   bool StartsWith( const wchar_t* t ) const noexcept
   {
#ifdef __PCL_WINDOWS
      return string_base::StartsWith( reinterpret_cast<const_iterator>( t ) );
#else
      return string_base::StartsWith( String( t ) );
#endif
   }
 
   bool StartsWith( wchar_t c ) const noexcept
   {
      return string_base::StartsWith( char_type( c ) );
   }
 
   bool StartsWithIC( const wchar_t* t ) const noexcept
   {
#ifdef __PCL_WINDOWS
      return string_base::StartsWithIC( reinterpret_cast<const_iterator>( t ) );
#else
      return string_base::StartsWithIC( String( t ) );
#endif
   }
 
   bool StartsWithIC( wchar_t c ) const noexcept
   {
      return string_base::StartsWithIC( char_type( c ) );
   }
 
   bool StartsWith( const_c_string8 t ) const noexcept
   {
      size_type n = char8_traits::Length( t );
      if ( n == 0 || Length() < n )
         return false;
      for ( const_iterator p = m_data->string, q = p+n; p < q; ++p, ++t )
         if ( *p != char_type( *t ) )
            return false;
      return true;
   }
 
   bool StartsWith( char8_type c ) const noexcept
   {
      return string_base::StartsWith( char_type( c ) );
   }
 
   bool StartsWithIC( const_c_string8 t ) const noexcept
   {
      size_type n = char8_traits::Length( t );
      if ( n == 0 || Length() < n )
         return false;
      for ( const_iterator p = m_data->string, q = p+n; p < q; ++p, ++t )
         if ( char_traits::ToCaseFolded( *p ) != char_type( char8_traits::ToCaseFolded( *t ) ) )
            return false;
      return true;
   }
 
   bool StartsWithIC( char8_type c ) const noexcept
   {
      return string_base::StartsWithIC( char_type( c ) );
   }
 
   // -------------------------------------------------------------------------
 
   bool EndsWith( const String& s ) const noexcept
   {
      return string_base::EndsWith( s );
   }
 
   bool EndsWith( const_iterator t ) const noexcept
   {
      return string_base::EndsWith( t );
   }
 
   bool EndsWith( char_type c ) const noexcept
   {
      return string_base::EndsWith( c );
   }
 
   bool EndsWithIC( const String& s ) const noexcept
   {
      return string_base::EndsWithIC( s );
   }
 
   bool EndsWithIC( const_iterator t ) const noexcept
   {
      return string_base::EndsWithIC( t );
   }
 
   bool EndsWithIC( char_type c ) const noexcept
   {
      return string_base::EndsWithIC( c );
   }
 
   bool EndsWith( const char16_t* t ) const noexcept
   {
      return string_base::EndsWith( reinterpret_cast<const_iterator>( t ) );
   }
 
   bool EndsWith( char16_t c ) const noexcept
   {
      return string_base::EndsWith( char_type( c ) );
   }
 
   bool EndsWithIC( const char16_t* t ) const noexcept
   {
      return string_base::EndsWithIC( reinterpret_cast<const_iterator>( t ) );
   }
 
   bool EndsWithIC( char16_t c ) const noexcept
   {
      return string_base::EndsWithIC( char_type( c ) );
   }
 
   bool EndsWith( const wchar_t* t ) const noexcept
   {
#ifdef __PCL_WINDOWS
      return string_base::EndsWith( reinterpret_cast<const_iterator>( t ) );
#else
      return string_base::EndsWith( String( t ) );
#endif
   }
 
   bool EndsWith( wchar_t c ) const noexcept
   {
      return string_base::EndsWith( char_type( c ) );
   }
 
   bool EndsWithIC( const wchar_t* t ) const noexcept
   {
#ifdef __PCL_WINDOWS
      return string_base::EndsWithIC( reinterpret_cast<const_iterator>( t ) );
#else
      return string_base::EndsWithIC( String( t ) );
#endif
   }
 
   bool EndsWithIC( wchar_t c ) const noexcept
   {
      return string_base::EndsWithIC( char_type( c ) );
   }
 
   bool EndsWith( const_c_string8 t ) const noexcept
   {
      size_type n = char8_traits::Length( t );
      if ( n == 0 || Length() < n )
         return false;
      for ( const_iterator p = m_data->end-n; p < m_data->end; ++p, ++t )
         if ( *p != char_type( *t ) )
            return false;
      return true;
   }
 
   bool EndsWith( char8_type c ) const noexcept
   {
      return string_base::EndsWith( char_type( c ) );
   }
 
   bool EndsWithIC( const_c_string8 t ) const noexcept
   {
      size_type n = char8_traits::Length( t );
      if ( n == 0 || Length() < n )
         return false;
      for ( const_iterator p = m_data->end-n; p < m_data->end; ++p, ++t )
         if ( char_traits::ToCaseFolded( *p ) != char_type( char8_traits::ToCaseFolded( *t ) ) )
            return false;
      return true;
   }
 
   bool EndsWithIC( char8_type c ) const noexcept
   {
      return string_base::EndsWithIC( char_type( c ) );
   }
 
   // -------------------------------------------------------------------------
 
   size_type FindFirst( const String& s, size_type i = 0 ) const noexcept
   {
      return string_base::FindFirst( s, i );
   }
 
   size_type FindFirst( const_iterator t, size_type i = 0 ) const noexcept
   {
      return string_base::FindFirst( t, i );
   }
 
   size_type FindFirst( char_type c, size_type i = 0 ) const noexcept
   {
      return string_base::FindFirst( c, i );
   }
 
   size_type FindFirstIC( const String& s, size_type i = 0 ) const noexcept
   {
      return string_base::FindFirstIC( s, i );
   }
 
   size_type FindFirstIC( const_iterator t, size_type i = 0 ) const noexcept
   {
      return string_base::FindFirstIC( t, i );
   }
 
   size_type FindFirstIC( char_type c, size_type i = 0 ) const noexcept
   {
      return string_base::FindFirstIC( c, i );
   }
 
   size_type FindFirst( const char16_t* t, size_type i = 0 ) const noexcept
   {
      return string_base::FindFirst( reinterpret_cast<const_iterator>( t ), i );
   }
 
   size_type FindFirst( char16_t c, size_type i = 0 ) const noexcept
   {
      return string_base::FindFirst( char_type( c ), i );
   }
 
   size_type FindFirstIC( const char16_t* t, size_type i = 0 ) const noexcept
   {
      return string_base::FindFirstIC( reinterpret_cast<const_iterator>( t ), i );
   }
 
   size_type FindFirstIC( char16_t c, size_type i = 0 ) const noexcept
   {
      return string_base::FindFirstIC( char_type( c ), i );
   }
 
   size_type FindFirst( const wchar_t* t, size_type i = 0 ) const noexcept
   {
#ifdef __PCL_WINDOWS
      return string_base::FindFirst( reinterpret_cast<const_iterator>( t ), i );
#else
      return string_base::FindFirst( String( t ), i );
#endif
   }
 
   size_type FindFirst( wchar_t c, size_type i = 0 ) const noexcept
   {
      return string_base::FindFirst( char_type( c ), i );
   }
 
   size_type FindFirstIC( const wchar_t* t, size_type i = 0 ) const noexcept
   {
#ifdef __PCL_WINDOWS
      return string_base::FindFirstIC( reinterpret_cast<const_iterator>( t ), i );
#else
      return string_base::FindFirstIC( String( t ), i );
#endif
   }
 
   size_type FindFirstIC( wchar_t c, size_type i = 0 ) const noexcept
   {
      return string_base::FindFirstIC( char_type( c ), i );
   }
 
   size_type FindFirst( const_c_string8 t, size_type i = 0 ) const noexcept
   {
      return string_base::FindFirst( String( t ), i );
   }
 
   size_type FindFirst( char8_type c, size_type i = 0 ) const noexcept
   {
      return string_base::FindFirst( char_type( c ), i );
   }
 
   size_type FindFirstIC( const_c_string8 t, size_type i = 0 ) const noexcept
   {
      return string_base::FindFirstIC( String( t ), i );
   }
 
   size_type FindFirstIC( char8_type c, size_type i = 0 ) const noexcept
   {
      return string_base::FindFirstIC( char_type( c ), i );
   }
 
   //
 
   size_type Find( const String& s, size_type i = 0 ) const noexcept
   {
      return FindFirst( s, i );
   }
 
   size_type Find( const_iterator t, size_type i = 0 ) const noexcept
   {
      return FindFirst( t, i );
   }
 
   size_type Find( char_type c, size_type i = 0 ) const noexcept
   {
      return FindFirst( c, i );
   }
 
   size_type Find( const char16_t* t, size_type i = 0 ) const noexcept
   {
      return FindFirst( t, i );
   }
 
   size_type Find( char16_t c, size_type i = 0 ) const noexcept
   {
      return FindFirst( c, i );
   }
 
   size_type Find( const wchar_t* t, size_type i = 0 ) const noexcept
   {
      return FindFirst( t, i );
   }
 
   size_type Find( wchar_t c, size_type i = 0 ) const noexcept
   {
      return FindFirst( c, i );
   }
 
   size_type Find( const_c_string8 t, size_type i = 0 ) const noexcept
   {
      return FindFirst( t, i );
   }
 
   size_type Find( char8_type c, size_type i = 0 ) const noexcept
   {
      return FindFirst( c, i );
   }
 
   size_type FindIC( const String& s, size_type i = 0 ) const noexcept
   {
      return FindFirstIC( s, i );
   }
 
   size_type FindIC( const_iterator t, size_type i = 0 ) const noexcept
   {
      return FindFirstIC( t, i );
   }
 
   size_type FindIC( char_type c, size_type i = 0 ) const noexcept
   {
      return FindFirstIC( c, i );
   }
 
   size_type FindIC( const char16_t* t, size_type i = 0 ) const noexcept
   {
      return FindFirstIC( t, i );
   }
 
   size_type FindIC( char16_t c, size_type i = 0 ) const noexcept
   {
      return FindFirstIC( c, i );
   }
 
   size_type FindIC( const wchar_t* t, size_type i = 0 ) const noexcept
   {
      return FindFirstIC( t, i );
   }
 
   size_type FindIC( wchar_t c, size_type i = 0 ) const noexcept
   {
      return FindFirstIC( c, i );
   }
 
   size_type FindIC( const_c_string8 t, size_type i = 0 ) const noexcept
   {
      return FindFirstIC( t, i );
   }
 
   size_type FindIC( char8_type c, size_type i = 0 ) const noexcept
   {
      return FindFirstIC( c, i );
   }
 
   // -------------------------------------------------------------------------
 
   size_type FindLast( const String& s, size_type r = maxPos ) const noexcept
   {
      return string_base::FindLast( s, r );
   }
 
   size_type FindLast( const_iterator t, size_type r = maxPos ) const noexcept
   {
      return string_base::FindLast( t, r );
   }
 
   size_type FindLast( char_type c, size_type r = maxPos ) const noexcept
   {
      return string_base::FindLast( c, r );
   }
 
   size_type FindLastIC( const String& s, size_type r = maxPos ) const noexcept
   {
      return string_base::FindLastIC( s, r );
   }
 
   size_type FindLastIC( const_iterator t, size_type r = maxPos ) const noexcept
   {
      return string_base::FindLastIC( t, r );
   }
 
   size_type FindLastIC( char_type c, size_type r = maxPos ) const noexcept
   {
      return string_base::FindLastIC( c, r );
   }
 
   size_type FindLast( const char16_t* t, size_type r = maxPos ) const noexcept
   {
      return string_base::FindLast( reinterpret_cast<const_iterator>( t ), r );
   }
 
   size_type FindLast( char16_t c, size_type r = maxPos ) const noexcept
   {
      return string_base::FindLast( char_type( c ), r );
   }
 
   size_type FindLastIC( const char16_t* t, size_type r = maxPos ) const noexcept
   {
      return string_base::FindLastIC( reinterpret_cast<const_iterator>( t ), r );
   }
 
   size_type FindLastIC( char16_t c, size_type r = maxPos ) const noexcept
   {
      return string_base::FindLastIC( char_type( c ), r );
   }
 
   size_type FindLast( const wchar_t* t, size_type r = maxPos ) const noexcept
   {
#ifdef __PCL_WINDOWS
      return string_base::FindLast( reinterpret_cast<const_iterator>( t ), r );
#else
      return string_base::FindLast( String( t ), r );
#endif
   }
 
   size_type FindLast( wchar_t c, size_type r = maxPos ) const noexcept
   {
      return string_base::FindLast( char_type( c ), r );
   }
 
   size_type FindLastIC( const wchar_t* t, size_type r = maxPos ) const noexcept
   {
#ifdef __PCL_WINDOWS
      return string_base::FindLastIC( reinterpret_cast<const_iterator>( t ), r );
#else
      return string_base::FindLastIC( String( t ), r );
#endif
   }
 
   size_type FindLastIC( wchar_t c, size_type r = maxPos ) const noexcept
   {
      return string_base::FindLastIC( char_type( c ), r );
   }
 
   size_type FindLast( const_c_string8 t, size_type r = maxPos ) const noexcept
   {
      return string_base::FindLast( String( t ), r );
   }
 
   size_type FindLast( char8_type c, size_type r = maxPos ) const noexcept
   {
      return string_base::FindLast( char_type( c ), r );
   }
 
   size_type FindLastIC( const_c_string8 t, size_type r = maxPos ) const noexcept
   {
      return string_base::FindLastIC( String( t ), r );
   }
 
   size_type FindLastIC( char8_type c, size_type r = maxPos ) const noexcept
   {
      return string_base::FindLastIC( char_type( c ), r );
   }
 
   // -------------------------------------------------------------------------
 
   bool Contains( const String& s ) const noexcept
   {
      return string_base::Contains( s );
   }
 
   bool Contains( const_iterator t ) const noexcept
   {
      return string_base::Contains( t );
   }
 
   bool Contains( char_type c ) const noexcept
   {
      return string_base::Contains( c );
   }
 
   bool ContainsIC( const String& s ) const noexcept
   {
      return string_base::ContainsIC( s );
   }
 
   bool ContainsIC( const_iterator t ) const noexcept
   {
      return string_base::ContainsIC( t );
   }
 
   bool ContainsIC( char_type c ) const noexcept
   {
      return string_base::ContainsIC( c );
   }
 
   bool Contains( const char16_t* t ) const noexcept
   {
      return string_base::Contains( reinterpret_cast<const_iterator>( t ) );
   }
 
   bool Contains( char16_t c ) const noexcept
   {
      return string_base::Contains( char_type( c ) );
   }
 
   bool ContainsIC( const char16_t* t ) const noexcept
   {
      return string_base::ContainsIC( reinterpret_cast<const_iterator>( t ) );
   }
 
   bool ContainsIC( char16_t c ) const noexcept
   {
      return string_base::ContainsIC( char_type( c ) );
   }
 
   bool Contains( const wchar_t* t ) const noexcept
   {
#ifdef __PCL_WINDOWS
      return string_base::Contains( reinterpret_cast<const_iterator>( t ) );
#else
      return string_base::Contains( String( t ) );
#endif
   }
 
   bool Contains( wchar_t c ) const noexcept
   {
      return string_base::Contains( char_type( c ) );
   }
 
   bool ContainsIC( const wchar_t* t ) const noexcept
   {
#ifdef __PCL_WINDOWS
      return string_base::ContainsIC( reinterpret_cast<const_iterator>( t ) );
#else
      return string_base::ContainsIC( String( t ) );
#endif
   }
 
   bool ContainsIC( wchar_t c ) const noexcept
   {
      return string_base::ContainsIC( char_type( c ) );
   }
 
   bool Contains( const_c_string8 t ) const noexcept
   {
      return string_base::Contains( String( t ) );
   }
 
   bool Contains( char8_type c ) const noexcept
   {
      return string_base::Contains( char_type( c ) );
   }
 
   bool ContainsIC( const_c_string8 t ) const noexcept
   {
      return string_base::ContainsIC( String( t ) );
   }
 
   bool ContainsIC( char8_type c ) const noexcept
   {
      return string_base::ContainsIC( char_type( c ) );
   }
 
   // -------------------------------------------------------------------------
 
   int CompareCodePoints( const String& s, bool caseSensitive = true ) const noexcept
   {
      return string_base::CompareCodePoints( s, caseSensitive );
   }
 
   int CompareCodePoints( const_iterator t, bool caseSensitive = true ) const noexcept
   {
      return string_base::CompareCodePoints( t, caseSensitive );
   }
 
   int CompareCodePoints( char_type c, bool caseSensitive = true ) const noexcept
   {
      return string_base::CompareCodePoints( c, caseSensitive );
   }
 
   int CompareCodePoints( const char16_t* t, bool caseSensitive = true ) const noexcept
   {
      return string_base::CompareCodePoints( reinterpret_cast<const_iterator>( t ), caseSensitive );
   }
 
   int CompareCodePoints( char16_t c, bool caseSensitive = true ) const noexcept
   {
      return string_base::CompareCodePoints( char_type( c ), caseSensitive );
   }
 
   int CompareCodePoints( const wchar_t* t, bool caseSensitive = true ) const noexcept
   {
#ifdef __PCL_WINDOWS
      return string_base::CompareCodePoints( reinterpret_cast<const_iterator>( t ), caseSensitive );
#else
      return string_base::CompareCodePoints( String( t ), caseSensitive );
#endif
   }
 
   int CompareCodePoints( wchar_t c, bool caseSensitive = true ) const noexcept
   {
      return string_base::CompareCodePoints( char_type( c ), caseSensitive );
   }
 
   int CompareCodePoints( const_c_string8 t, bool caseSensitive = true ) const noexcept
   {
      return string_base::CompareCodePoints( String( t ), caseSensitive );
   }
 
   int CompareCodePoints( char8_type c, bool caseSensitive = true ) const noexcept
   {
      return string_base::CompareCodePoints( char_type( c ), caseSensitive );
   }
 
   // -------------------------------------------------------------------------
 
   int Compare( const String& s, bool caseSensitive = true, bool localeAware = true ) const noexcept
   {
      return string_base::Compare( s, caseSensitive, localeAware );
   }
 
   int Compare( const_iterator t, bool caseSensitive = true, bool localeAware = true ) const noexcept
   {
      return string_base::Compare( t, caseSensitive, localeAware );
   }
 
   int Compare( char_type c, bool caseSensitive = true, bool localeAware = true ) const noexcept
   {
      return string_base::Compare( c, caseSensitive, localeAware );
   }
 
   int CompareIC( const String& s, bool localeAware = true ) const noexcept
   {
      return string_base::CompareIC( s, localeAware );
   }
 
   int CompareIC( const_iterator t, bool localeAware = true ) const noexcept
   {
      return string_base::CompareIC( t, localeAware );
   }
 
   int CompareIC( char_type c, bool localeAware = true ) const noexcept
   {
      return string_base::CompareIC( c, localeAware );
   }
 
   int Compare( const char16_t* t, bool caseSensitive = true, bool localeAware = true ) const noexcept
   {
      return string_base::Compare( reinterpret_cast<const_iterator>( t ), caseSensitive, localeAware );
   }
 
   int Compare( char16_t c, bool caseSensitive = true, bool localeAware = true ) const noexcept
   {
      return string_base::Compare( char_type( c ), caseSensitive, localeAware );
   }
 
   int CompareIC( const char16_t* t, bool localeAware = true ) const noexcept
   {
      return string_base::CompareIC( reinterpret_cast<const_iterator>( t ), localeAware );
   }
 
   int CompareIC( char16_t c, bool localeAware = true ) const noexcept
   {
      return string_base::CompareIC( char_type( c ), localeAware );
   }
 
   int Compare( const wchar_t* t, bool caseSensitive = true, bool localeAware = true ) const noexcept
   {
#ifdef __PCL_WINDOWS
      return string_base::Compare( reinterpret_cast<const_iterator>( t ), caseSensitive, localeAware );
#else
      return string_base::Compare( String( t ), caseSensitive, localeAware );
#endif
   }
 
   int Compare( wchar_t c, bool caseSensitive = true, bool localeAware = true ) const noexcept
   {
      return string_base::Compare( char_type( c ), caseSensitive, localeAware );
   }
 
   int CompareIC( const wchar_t* t, bool localeAware = true ) const noexcept
   {
#ifdef __PCL_WINDOWS
      return string_base::CompareIC( reinterpret_cast<const_iterator>( t ), localeAware );
#else
      return string_base::CompareIC( String( t ), localeAware );
#endif
   }
 
   int CompareIC( wchar_t c, bool localeAware = true ) const noexcept
   {
      return string_base::CompareIC( char_type( c ), localeAware );
   }
 
   int Compare( const_c_string8 t, bool caseSensitive = true, bool localeAware = true ) const noexcept
   {
      return string_base::Compare( String( t ), caseSensitive, localeAware );
   }
 
   int Compare( char8_type c, bool caseSensitive = true, bool localeAware = true ) const noexcept
   {
      return string_base::Compare( char_type( c ), caseSensitive, localeAware );
   }
 
   int CompareIC( const_c_string8 t, bool localeAware = true ) const noexcept
   {
      return string_base::CompareIC( String( t ), localeAware );
   }
 
   int CompareIC( char8_type c, bool localeAware = true ) const noexcept
   {
      return string_base::CompareIC( char_type( c ), localeAware );
   }
 
   // -------------------------------------------------------------------------
 
   bool WildMatch( const String& pattern, bool caseSensitive = true ) const noexcept
   {
      return string_base::WildMatch( pattern, caseSensitive );
   }
 
   bool WildMatchIC( const String& pattern ) const noexcept
   {
      return string_base::WildMatchIC( pattern );
   }
 
   bool WildMatch( const_iterator pattern, bool caseSensitive = true ) const noexcept
   {
      return string_base::WildMatch( pattern, caseSensitive );
   }
 
   bool WildMatchIC( const_iterator pattern ) const noexcept
   {
      return string_base::WildMatchIC( pattern );
   }
 
   bool WildMatch( const string8_base& pattern, bool caseSensitive = true ) const noexcept
   {
      return char_traits::WildMatch( m_data->string, Length(), pattern.Begin(), pattern.Length(), caseSensitive );
   }
 
   bool WildMatchIC( const string8_base& pattern ) const noexcept
   {
      return char_traits::WildMatch( m_data->string, Length(), pattern.Begin(), pattern.Length(), false/*caseSensitive*/ );
   }
 
   bool WildMatch( const_c_string8 pattern, bool caseSensitive = true ) const noexcept
   {
      return char_traits::WildMatch( m_data->string, Length(), pattern, char8_traits::Length( pattern ), caseSensitive );
   }
 
   bool WildMatchIC( const_c_string8 pattern ) const noexcept
   {
      return char_traits::WildMatch( m_data->string, Length(), pattern, char8_traits::Length( pattern ), false/*caseSensitive*/ );
   }
 
   // -------------------------------------------------------------------------
 
   String SetToLength( size_type n ) const
   {
      return string_base::SetToLength( n );
   }
 
   String ResizedToNullTerminated() const
   {
      return string_base::ResizedToNullTerminated();
   }
 
   String Squeezed() const
   {
      return string_base::Squeezed();
   }
 
   // -------------------------------------------------------------------------
 
   String Substring( size_type i, size_type n = maxPos ) const
   {
      return string_base::Substring( i, n );
   }
 
   String Left( size_type n ) const
   {
      return string_base::Left( n );
   }
 
   String Right( size_type n ) const
   {
      return string_base::Right( n );
   }
 
   String Suffix( size_type i ) const
   {
      return string_base::Suffix( i );
   }
 
   String Prefix( size_type i ) const
   {
      return string_base::Prefix( i );
   }
 
   // -------------------------------------------------------------------------
 
   template <class C>
   size_type Break( C& list, const String& s, bool trim = false, size_type i = 0 ) const
   {
      return string_base::Break( list, s, trim, i );
   }
 
   template <class C>
   size_type Break( C& list, const string8_base& s, bool trim = false, size_type i = 0 ) const
   {
      return string_base::Break( list, String( s ), trim, i );
   }
 
   template <class C>
   size_type Break( C& list, const_c_string8 s, bool trim = false, size_type i = 0 ) const
   {
      return string_base::Break( list, String( s ), trim, i );
   }
 
   template <class C>
   size_type Break( C& list, char_type c, bool trim = false, size_type i = 0 ) const
   {
      return string_base::Break( list, c, trim, i );
   }
 
   template <class C>
   size_type Break( C& list, char8_type c, bool trim = false, size_type i = 0 ) const
   {
      return string_base::Break( list, char_type( c ), trim, i );
   }
 
   template <class C, typename S>
   size_type Break( C& list, const Array<S>& ca, bool trim = false, size_type i = 0 ) const
   {
      return string_base::Break( list, ca, trim, i );
   }
 
   // -------------------------------------------------------------------------
 
   template <class C>
   size_type BreakIC( C& list, const String& s, bool trim = false, size_type i = 0 ) const
   {
      return string_base::BreakIC( list, s, trim, i );
   }
 
   template <class C>
   size_type BreakIC( C& list, const string8_base& s, bool trim = false, size_type i = 0 ) const
   {
      return string_base::BreakIC( list, String( s ), trim, i );
   }
 
   template <class C>
   size_type BreakIC( C& list, const_c_string8 s, bool trim = false, size_type i = 0 ) const
   {
      return string_base::BreakIC( list, String( s ), trim, i );
   }
 
   template <class C>
   size_type BreakIC( C& list, char_type c, bool trim = false, size_type i = 0 ) const
   {
      return string_base::BreakIC( list, c, trim, i );
   }
 
   template <class C>
   size_type BreakIC( C& list, char8_type c, bool trim = false, size_type i = 0 ) const
   {
      return string_base::BreakIC( list, char_type( c ), trim, i );
   }
 
   // -------------------------------------------------------------------------
 
   String Trimmed() const
   {
      return string_base::Trimmed();
   }
 
   String TrimmedLeft() const
   {
      return string_base::TrimmedLeft();
   }
 
   String TrimmedRight() const
   {
      return string_base::TrimmedRight();
   }
 
   // -------------------------------------------------------------------------
 
   String LeftJustified( size_type width, char_type fill = CharTraits::Blank() ) const
   {
      return string_base::LeftJustified( width, fill );
   }
 
   String RightJustified( size_type width, char_type fill = CharTraits::Blank() ) const
   {
      return string_base::RightJustified( width, fill );
   }
 
   String CenterJustified( size_type width, char_type fill = CharTraits::Blank() ) const
   {
      return string_base::CenterJustified( width, fill );
   }
 
   // -------------------------------------------------------------------------
 
   String Enclosed( char_type c ) const
   {
      return string_base::Enclosed( c );
   }
 
   String SingleQuoted() const
   {
      return string_base::SingleQuoted();
   }
 
   String DoubleQuoted() const
   {
      return string_base::DoubleQuoted();
   }
 
   String Unquoted() const
   {
      return string_base::Unquoted();
   }
 
   // -------------------------------------------------------------------------
 
   String CaseFolded() const
   {
      return string_base::CaseFolded();
   }
 
   String Lowercase() const
   {
      return string_base::Lowercase();
   }
 
   String Uppercase() const
   {
      return string_base::Uppercase();
   }
 
   // -------------------------------------------------------------------------
 
   String Reversed() const
   {
      return string_base::Reversed();
   }
 
   String Sorted() const
   {
      return string_base::Sorted();
   }
 
   template <class BP>
   String Sorted( BP p ) const
   {
      return string_base::Sorted( p );
   }
 
   // -------------------------------------------------------------------------
 
   template <class C>
   String& ToSeparated( const C& c, char_type separator )
   {
      Clear();
      return c.ToSeparated( *this, separator );
   }
 
   template <class C, class AF>
   String& ToSeparated( const C& c, char_type separator, AF append )
   {
      Clear();
      return c.ToSeparated( *this, separator, append );
   }
 
   template <class C>
   String& ToSeparated( const C& c, const String& separator )
   {
      Clear();
      return c.ToSeparated( *this, separator );
   }
 
   template <class C, class AF>
   String& ToSeparated( const C& c, const String& separator, AF append )
   {
      Clear();
      return c.ToSeparated( *this, separator, append );
   }
 
   template <class C>
   String& ToSeparated( const C& c, const_c_string separator )
   {
      return ToSeparated( c, String( separator ) );
   }
 
   template <class C, class AF>
   String& ToSeparated( const C& c, const_c_string separator, AF append )
   {
      return ToSeparated( c, String( separator ), append );
   }
 
   template <class C>
   String& ToSeparated( const C& c, const_c_string8 separator )
   {
      return ToSeparated( c, String( separator ) );
   }
 
   template <class C, class AF>
   String& ToSeparated( const C& c, const_c_string8 separator, AF append )
   {
      return ToSeparated( c, String( separator ), append );
   }
 
   template <class C>
   String& ToCommaSeparated( const C& c )
   {
      return ToSeparated( c, CharTraits::Comma() );
   }
 
   template <class C>
   String& ToColonSeparated( const C& c )
   {
      return ToSeparated( c, CharTraits::Colon() );
   }
 
   template <class C>
   String& ToSpaceSeparated( const C& c )
   {
      return ToSeparated( c, CharTraits::Blank() );
   }
 
   template <class C>
   String& ToTabSeparated( const C& c )
   {
      return ToSeparated( c, CharTraits::Tab() );
   }
 
   template <class C>
   String& ToNewLineSeparated( const C& c )
   {
      return ToSeparated( c, CharTraits::LF() );
   }
 
   template <class C>
   String& ToNullSeparated( const C& c )
   {
      return ToSeparated( c, CharTraits::Null() );
   }
 
   template <class C>
   String& ToHyphenated( const C& c )
   {
      return ToSeparated( c, CharTraits::Hyphen() );
   }
 
   // -------------------------------------------------------------------------
 
   String& ToEncodedHTMLSpecialChars();
 
   String EncodedHTMLSpecialChars() const
   {
      return String( *this ).ToEncodedHTMLSpecialChars();
   }
 
   String& ToDecodedHTMLSpecialChars();
 
   String DecodedHTMLSpecialChars() const
   {
      return String( *this ).ToDecodedHTMLSpecialChars();
   }
 
   // -------------------------------------------------------------------------
 
#ifdef __PCL_QT_INTERFACE
 
   operator QString() const
   {
      return PCL_GET_QSTRING_FROM_CHAR16PTR( c_str() );
   }
 
   operator QDate() const
   {
      return QDate::fromString( operator QString(), PCL_QDATE_FMT_STR );
   }
 
   operator QDateTime() const
   {
      return QDateTime::fromString( operator QString(), PCL_QDATETIME_FMT_STR );
   }
 
#endif
 
   String& Format( const_c_string8 fmt, ... )
   {
      va_list paramList;
      va_start( paramList, fmt );
 
      (void)VFormat( fmt, paramList );
 
      va_end( paramList );
      return *this;
   }
 
   String& AppendFormat( const_c_string8 fmt, ... )
   {
      va_list paramList;
      va_start( paramList, fmt );
 
      (void)AppendVFormat( fmt, paramList );
 
      va_end( paramList );
      return *this;
   }
 
   int VFormat( const_c_string8 fmt, va_list paramList )
   {
      IsoString s;
      int count = s.VFormat( fmt, paramList );
      Assign( s );
      return count;
   }
 
   int AppendVFormat( const_c_string8 fmt, va_list paramList )
   {
      IsoString s;
      int count = s.VFormat( fmt, paramList );
      Append( s );
      return count;
   }
 
   String& Format( const wchar_t* fmt, ... )
   {
      va_list paramList;
      va_start( paramList, fmt );
 
      (void)VFormat( fmt, paramList );
 
      va_end( paramList );
      return *this;
   }
 
   String& AppendFormat( const wchar_t* fmt, ... )
   {
      va_list paramList;
      va_start( paramList, fmt );
 
      (void)AppendVFormat( fmt, paramList );
 
      va_end( paramList );
      return *this;
   }
 
   int VFormat( const wchar_t* fmt, va_list paramList );
 
   int AppendVFormat( const wchar_t* fmt, va_list paramList );
 
   // -------------------------------------------------------------------------
 
   static String UTF8ToUTF16( const_c_string8 string, size_type i = 0, size_type n = maxPos );
 
   static IsoString UTF16ToUTF8( const_c_string string, size_type i = 0, size_type n = maxPos );
 
   static Array<uint32> UTF16ToUTF32( const_c_string string, size_type i = 0, size_type n = maxPos );
 
   static String UTF32ToUTF16( const uint32* string, size_type i = 0, size_type n = maxPos );
 
   // -------------------------------------------------------------------------
 
   IsoString ToIsoString() const;
 
   IsoString To7BitASCII() const;
 
   IsoString ToUTF8( size_type i = 0, size_type n = maxPos ) const
   {
      return UTF16ToUTF8( Begin(), i, n );
   }
 
   IsoString ToMBS() const;
 
   IsoString ToLocal8Bit() const
   {
#ifdef __PCL_WINDOWS
      return ToMBS();
#else
      return ToUTF8();
#endif
   }
 
   Array<wchar_t> ToWCharArray( size_type i = 0, size_type n = maxPos ) const
   {
      if ( n > 0 )
      {
         size_type len = Length();
         if ( i < len )
         {
            n = pcl::Min( n, len-i );
            Array<wchar_t> a( n+1, wchar_t( 0 ) );
#ifdef __PCL_WINDOWS
            char_traits::Copy( reinterpret_cast<iterator>( a.Begin() ), m_data->string+i, n );
#else
            Array<wchar_t>::iterator w = a.Begin();
            for ( const_iterator s = m_data->string+i, e = s+n; s < e; ++w, ++s )
               *w = wchar_t( *s );
#endif // __PCL_WINDOWS
            return a;
         }
      }
 
      return Array<wchar_t>( size_type( 1 ), wchar_t( 0 ) );
   }
 
   Array<uint32> ToUTF32( size_type i = 0, size_type n = maxPos ) const
   {
      return UTF16ToUTF32( Begin(), i, n );
   }
 
#ifdef __PCL_QT_INTERFACE
 
   QString ToQString() const
   {
      return operator QString();
   }
 
   QDate ToQDate() const
   {
      return operator QDate();
   }
 
   QDateTime ToQDateTime() const
   {
      return operator QDateTime();
   }
 
#endif
 
   bool ToBool() const;
 
   bool TryToBool( bool& value ) const noexcept;
 
   float ToFloat() const;
 
   bool TryToFloat( float& value ) const noexcept;
 
   double ToDouble() const;
 
   bool TryToDouble( double& value ) const noexcept;
 
   long ToInt() const
   {
      return ToInt( 0 );
   }
 
   bool TryToInt( int& value ) const noexcept
   {
      return TryToInt( value, 0 );
   }
 
   long ToInt( int base ) const;
 
   bool TryToInt( int& value, int base ) const noexcept;
 
   unsigned long ToUInt() const
   {
      return ToUInt( 0 );
   }
 
   bool TryToUInt( unsigned& value ) const noexcept
   {
      return TryToUInt( value, 0 );
   }
 
   unsigned long ToUInt( int base ) const;
 
   bool TryToUInt( unsigned& value, int base ) const noexcept;
 
   long long ToInt64() const
   {
      return ToInt64( 0 );
   }
 
   bool TryToInt64( long long& value ) const noexcept
   {
      return TryToInt64( value, 0 );
   }
 
   long long ToInt64( int base ) const;
 
   bool TryToInt64( long long& value, int base ) const noexcept;
 
   unsigned long long ToUInt64() const
   {
      return ToUInt64( 0 );
   }
 
   bool TryToUInt64( unsigned long long& value ) const noexcept
   {
      return TryToUInt64( value, 0 );
   }
 
   unsigned long long ToUInt64( int base ) const;
 
   bool TryToUInt64( unsigned long long& value, int base ) const noexcept;
 
   Array<float> ParseListOfFloat( char separator = ',', size_type maxCount = ~size_type( 0 ) ) const;
 
   Array<double> ParseListOfDouble( char separator = ',', size_type maxCount = ~size_type( 0 ) ) const;
 
#ifndef __PCL_NO_STRING_VECTOR
 
   GenericVector<float> ParseListOfFloatAsVector( char separator = ',', int maxCount = int_max ) const;
 
   GenericVector<double> ParseListOfDoubleAsVector( char separator = ',', int maxCount = int_max ) const;
 
#endif   // !__PCL_NO_STRING_VECTOR
 
   double SexagesimalToDouble( const String& separator = ':' ) const
   {
      int sign, s1, s2; double s3;
      ParseSexagesimal( sign, s1, s2, s3, separator );
      return sign*(s1 + (s2 + s3/60)/60);
   }
 
   double SexagesimalToDouble( const Array<char_type>& separators ) const
   {
      int sign, s1, s2; double s3;
      ParseSexagesimal( sign, s1, s2, s3, separators );
      return sign*(s1 + (s2 + s3/60)/60);
   }
 
   bool TrySexagesimalToDouble( double& value, const String& separator = ':' ) const noexcept
   {
      int sign, s1, s2; double s3;
      if ( TryParseSexagesimal( sign, s1, s2, s3, separator ) )
      {
         value = sign*(s1 + (s2 + s3/60)/60);
         return true;
      }
      return false;
   }
 
   bool TrySexagesimalToDouble( double& value, const Array<char_type>& separators ) const noexcept
   {
      int sign, s1, s2; double s3;
      if ( TryParseSexagesimal( sign, s1, s2, s3, separators ) )
      {
         value = sign*(s1 + (s2 + s3/60)/60);
         return true;
      }
      return false;
   }
 
   void ParseSexagesimal( int& sign, int& s1, int& s2, double& s3, const String& separator = ':' ) const;
 
   void ParseSexagesimal( int& sign, int& s1, int& s2, double& s3, const Array<char_type>& separators ) const;
 
   bool TryParseSexagesimal( int& sign, int& s1, int& s2, double& s3, const String& separator = ':' ) const noexcept;
 
   bool TryParseSexagesimal( int& sign, int& s1, int& s2, double& s3, const Array<char_type>& separators ) const noexcept;
 
   static String ToSexagesimal( int sign, double s1, double s2, double s3,
                                const SexagesimalConversionOptions& options = SexagesimalConversionOptions() );
 
   static String ToSexagesimal( double d, const SexagesimalConversionOptions& options = SexagesimalConversionOptions() )
   {
      return ToSexagesimal( (d < 0) ? -1 : +1, Abs( d ), 0, 0, options );
   }
 
   void ParseISO8601DateTime( int& year, int& month, int& day, double& dayf, double& tz ) const;
 
   bool TryParseISO8601DateTime( int& year, int& month, int& day, double& dayf, double& tz ) const noexcept;
 
   static String ToISO8601DateTime( int year, int month, int day, double dayf, double tz = 0,
                                    const ISO8601ConversionOptions& options = ISO8601ConversionOptions() );
 
   static String CurrentUTCISO8601DateTime( const ISO8601ConversionOptions& options = ISO8601ConversionOptions() );
 
   static String CurrentLocalISO8601DateTime( const ISO8601ConversionOptions& options = ISO8601ConversionOptions() );
 
   static String Random( size_type n, RandomizationOptions options = RandomizationOption::Default );
 
   static String UUID();
};
 
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
 
inline IsoString::IsoString( const_c_ustring t, size_type p, size_type n )
{
   size_type len = uchar_traits::Length( t );
   if ( p < len )
   {
      m_data->Allocate( n = pcl::Min( n, len-p ) );
      t += p;
      for ( iterator i = m_data->string; i < m_data->end; ++i, ++t )
         *i = char_type( uint8( *t ) );
   }
}
 
inline IsoString& IsoString::operator =( const_c_ustring t )
{
   size_type len = uchar_traits::Length( t );
   if ( len > 0 )
   {
      MaybeReallocate( len );
      for ( iterator i = m_data->string; i < m_data->end; ++i, ++t )
         *i = char_type( uint8( *t ) );
   }
   else
      Clear();
 
   return *this;
}
 
inline IsoString::ustring_base IsoString::UTF8ToUTF16( size_type i, size_type n ) const
{
   return String::UTF8ToUTF16( Begin(), i, n );
}
 
// ----------------------------------------------------------------------------
 
inline String operator +( const String::string_base& s1, const String::string_base& s2 )
{
   String s = s1;
   s.Append( s2 );
   return s;
}
 
inline String operator +( String::string_base&& s1, const String::string_base& s2 )
{
   s1.Append( s2 );
   return String( std::move( s1 ) );
}
 
inline String operator +( String&& s1, const String::string_base& s2 )
{
   s1.Append( s2 );
   return std::move( s1 );
}
 
inline String operator +( const String::string_base& s1, String::string_base&& s2 )
{
   s2.Prepend( s1 );
   return String( std::move( s2 ) );
}
 
inline String operator +( const String::string_base& s1, String&& s2 )
{
   s2.Prepend( s1 );
   return std::move( s2 );
}
 
inline String operator +( String::string_base&& s1, String::string_base&& s2 )
{
   s1.Append( s2 );
   return String( std::move( s1 ) );
}
 
inline String operator +( String&& s1, String::string_base&& s2 )
{
   s1.Append( s2 );
   return std::move( s1 );
}
 
inline String operator +( String::string_base&& s1, String&& s2 )
{
   s1.Append( s2 );
   return String( std::move( s1 ) );
}
 
inline String operator +( String&& s1, String&& s2 )
{
   s1.Append( s2 );
   return std::move( s1 );
}
 
// ----------------------------------------------------------------------------
 
inline String operator +( const String::string_base& s1, String::const_iterator t2 )
{
   String s = s1;
   s.Append( t2 );
   return s;
}
 
inline String operator +( String::string_base&& s1, String::const_iterator t2 )
{
   s1.Append( t2 );
   return String( std::move( s1 ) );
}
 
inline String operator +( String&& s1, String::const_iterator t2 )
{
   s1.Append( t2 );
   return std::move( s1 );
}
 
inline String operator +( String::const_iterator t1, const String::string_base& s2 )
{
   String s = s2;
   s.Prepend( t1 );
   return s;
}
 
inline String operator +( String::const_iterator t1, String::string_base&& s2 )
{
   s2.Prepend( t1 );
   return String( std::move( s2 ) );
}
 
inline String operator +( String::const_iterator t1, String&& s2 )
{
   s2.Prepend( t1 );
   return std::move( s2 );
}
 
// ----------------------------------------------------------------------------
 
inline String operator +( const String::string_base& s1, String::char_type c2 )
{
   String s = s1;
   s.Append( c2 );
   return s;
}
 
inline String operator +( String::string_base&& s1, String::char_type c2 )
{
   s1.Append( c2 );
   return String( std::move( s1 ) );
}
 
inline String operator +( String&& s1, String::char_type c2 )
{
   s1.Append( c2 );
   return std::move( s1 );
}
 
inline String operator +( String::char_type c1, const String::string_base& s2 )
{
   String s = s2;
   s.Prepend( c1 );
   return s;
}
 
inline String operator +( String::char_type c1, String::string_base&& s2 )
{
   s2.Prepend( c1 );
   return String( std::move( s2 ) );
}
 
inline String operator +( String::char_type c1, String&& s2 )
{
   s2.Prepend( c1 );
   return std::move( s2 );
}
 
// ----------------------------------------------------------------------------
 
inline String operator +( const String::string_base& s1, const char16_t* t2 )
{
   String s = s1;
   s.Append( t2 );
   return s;
}
 
inline String operator +( String::string_base&& s1, const char16_t* t2 )
{
   String s = std::move( s1 );
   s.Append( t2 );
   return s;
}
 
inline String operator +( String&& s1, const char16_t* t2 )
{
   s1.Append( t2 );
   return std::move( s1 );
}
 
inline String operator +( const char16_t* t1, const String::string_base& s2 )
{
   String s = s2;
   s.Prepend( t1 );
   return s;
}
 
inline String operator +( const char16_t* t1, String::string_base&& s2 )
{
   String s = std::move( s2 );
   s.Prepend( t1 );
   return s;
}
 
inline String operator +( const char16_t* t1, String&& s2 )
{
   s2.Prepend( t1 );
   return std::move( s2 );
}
 
// ----------------------------------------------------------------------------
 
inline String operator +( const String::string_base& s1, char16_t c2 )
{
   String s = s1;
   s.Append( c2 );
   return s;
}
 
inline String operator +( String::string_base&& s1, char16_t c2 )
{
   String s = std::move( s1 );
   s.Append( c2 );
   return s;
}
 
inline String operator +( String&& s1, char16_t c2 )
{
   s1.Append( c2 );
   return std::move( s1 );
}
 
inline String operator +( char16_t c1, const String::string_base& s2 )
{
   String s = s2;
   s.Prepend( c1 );
   return s;
}
 
inline String operator +( char16_t c1, String::string_base&& s2 )
{
   String s = std::move( s2 );
   s.Prepend( c1 );
   return s;
}
 
inline String operator +( char16_t c1, String&& s2 )
{
   s2.Prepend( c1 );
   return std::move( s2 );
}
 
// ----------------------------------------------------------------------------
 
inline String operator +( const String::string_base& s1, const wchar_t* t2 )
{
   String s = s1;
   s.Append( t2 );
   return s;
}
 
inline String operator +( String::string_base&& s1, const wchar_t* t2 )
{
   String s = std::move( s1 );
   s.Append( t2 );
   return s;
}
 
inline String operator +( String&& s1, const wchar_t* t2 )
{
   s1.Append( t2 );
   return std::move( s1 );
}
 
inline String operator +( const wchar_t* t1, const String::string_base& s2 )
{
   String s = s2;
   s.Prepend( t1 );
   return s;
}
 
inline String operator +( const wchar_t* t1, String::string_base&& s2 )
{
   String s = std::move( s2 );
   s.Prepend( t1 );
   return s;
}
 
inline String operator +( const wchar_t* t1, String&& s2 )
{
   s2.Prepend( t1 );
   return std::move( s2 );
}
 
// ----------------------------------------------------------------------------
 
inline String operator +( const String::string_base& s1, wchar_t c2 )
{
   String s = s1;
   s.Append( c2 );
   return s;
}
 
inline String operator +( String::string_base&& s1, wchar_t c2 )
{
   String s = std::move( s1 );
   s.Append( c2 );
   return s;
}
 
inline String operator +( String&& s1, wchar_t c2 )
{
   s1.Append( c2 );
   return std::move( s1 );
}
 
inline String operator +( wchar_t c1, const String::string_base& s2 )
{
   String s = s2;
   s.Prepend( c1 );
   return s;
}
 
inline String operator +( wchar_t c1, String::string_base&& s2 )
{
   String s = std::move( s2 );
   s.Prepend( c1 );
   return s;
}
 
inline String operator +( wchar_t c1, String&& s2 )
{
   s2.Prepend( c1 );
   return std::move( s2 );
}
 
// ----------------------------------------------------------------------------
 
inline String operator +( const String::string_base& s1, const String::string8_base& s2 )
{
   String s = s1;
   s.Append( s2 );
   return s;
}
 
inline String operator +( String::string_base&& s1, const String::string8_base& s2 )
{
   String s = std::move( s1 );
   s.Append( s2 );
   return s;
}
 
inline String operator +( String&& s1, const String::string8_base& s2 )
{
   s1.Append( s2 );
   return std::move( s1 );
}
 
inline String operator +( const String::string8_base& s1, const String::string_base& s2 )
{
   String s = s2;
   s.Prepend( s1 );
   return s;
}
 
inline String operator +( const String::string8_base& s1, String::string_base&& s2 )
{
   String s = std::move( s2 );
   s.Prepend( s1 );
   return s;
}
 
inline String operator +( const String::string8_base& s1, String&& s2 )
{
   s2.Prepend( s1 );
   return std::move( s2 );
}
 
// ----------------------------------------------------------------------------
 
inline String operator +( const String::string_base& s1, String::const_c_string8 t2 )
{
   String s = s1;
   s.Append( t2 );
   return s;
}
 
inline String operator +( String::string_base&& s1, String::const_c_string8 t2 )
{
   String s = std::move( s1 );
   s.Append( t2 );
   return s;
}
 
inline String operator +( String&& s1, String::const_c_string8 t2 )
{
   s1.Append( t2 );
   return std::move( s1 );
}
 
inline String operator +( String::const_c_string8 t1, const String::string_base& s2 )
{
   String s = s2;
   s.Prepend( t1 );
   return s;
}
 
inline String operator +( String::const_c_string8 t1, String::string_base&& s2 )
{
   String s = std::move( s2 );
   s.Prepend( t1 );
   return s;
}
 
inline String operator +( String::const_c_string8 t1, String&& s2 )
{
   s2.Prepend( t1 );
   return std::move( s2 );
}
 
// ----------------------------------------------------------------------------
 
inline String operator +( const String::string_base& s1, String::char8_type c2 )
{
   String s = s1;
   s.Append( c2 );
   return s;
}
 
inline String operator +( String::string_base&& s1, String::char8_type c2 )
{
   s1.Append( String::char_type( c2 ) );
   return String( std::move( s1 ) );
}
 
inline String operator +( String&& s1, String::char8_type c2 )
{
   s1.Append( c2 );
   return std::move( s1 );
}
 
inline String operator +( String::char8_type c1, const String::string_base& s2 )
{
   String s = s2;
   s.Prepend( c1 );
   return s;
}
 
inline String operator +( String::char8_type c1, String::string_base&& s2 )
{
   s2.Prepend( String::char_type( c1 ) );
   return String( std::move( s2 ) );
}
 
inline String operator +( String::char8_type c1, String&& s2 )
{
   s2.Prepend( c1 );
   return std::move( s2 );
}
 
// ----------------------------------------------------------------------------
 
inline String& operator <<( String& s1, const String::string_base& s2 )
{
   s1.Append( s2 );
   return s1;
}
 
inline String& operator <<( String&& s1, const String::string_base& s2 )
{
   s1.Append( s2 );
   return s1;
}
 
inline String& operator <<( String& s1, String::const_iterator& t2 )
{
   s1.Append( t2 );
   return s1;
}
 
inline String& operator <<( String&& s1, String::const_iterator& t2 )
{
   s1.Append( t2 );
   return s1;
}
 
inline String& operator <<( String& s1, String::char_type c2 )
{
   s1.Append( c2 );
   return s1;
}
 
inline String& operator <<( String&& s1, String::char_type c2 )
{
   s1.Append( c2 );
   return s1;
}
 
inline String& operator <<( String& s1, const char16_t* t2 )
{
   s1.Append( t2 );
   return s1;
}
 
inline String& operator <<( String&& s1, const char16_t* t2 )
{
   s1.Append( t2 );
   return s1;
}
 
inline String& operator <<( String& s1, char16_t c2 )
{
   s1.Append( c2 );
   return s1;
}
 
inline String& operator <<( String&& s1, char16_t c2 )
{
   s1.Append( c2 );
   return s1;
}
 
inline String& operator <<( String& s1, const wchar_t* t2 )
{
   s1.Append( t2 );
   return s1;
}
 
inline String& operator <<( String&& s1, const wchar_t* t2 )
{
   s1.Append( t2 );
   return s1;
}
 
inline String& operator <<( String& s1, wchar_t c2 )
{
   s1.Append( c2 );
   return s1;
}
 
inline String& operator <<( String&& s1, wchar_t c2 )
{
   s1.Append( c2 );
   return s1;
}
 
inline String& operator <<( String& s1, const String::string8_base& s2 )
{
   s1.Append( s2 );
   return s1;
}
 
inline String& operator <<( String&& s1, const String::string8_base& s2 )
{
   s1.Append( s2 );
   return s1;
}
 
inline String& operator <<( String& s1, String::const_c_string8 t2 )
{
   s1.Append( t2 );
   return s1;
}
 
inline String& operator <<( String&& s1, String::const_c_string8 t2 )
{
   s1.Append( t2 );
   return s1;
}
 
inline String& operator <<( String& s1, String::char8_type c2 )
{
   s1.Append( c2 );
   return s1;
}
 
inline String& operator <<( String&& s1, String::char8_type c2 )
{
   s1.Append( c2 );
   return s1;
}
 
// ----------------------------------------------------------------------------
 
inline bool operator ==( const String& s1, const char16_t* t2 ) noexcept
{
   return s1.CompareCodePoints( t2 ) == 0;
}
 
inline bool operator  <( const String& s1, const char16_t* t2 ) noexcept
{
   return s1.CompareCodePoints( t2 ) < 0;
}
 
inline bool operator <=( const String& s1, const char16_t* t2 ) noexcept
{
   return s1.CompareCodePoints( t2 ) <= 0;
}
 
inline bool operator  >( const String& s1, const char16_t* t2 ) noexcept
{
   return s1.CompareCodePoints( t2 ) > 0;
}
 
inline bool operator >=( const String& s1, const char16_t* t2 ) noexcept
{
   return s1.CompareCodePoints( t2 ) >= 0;
}
 
// ----------------------------------------------------------------------------
 
inline bool operator ==( const char16_t* t1, const String& s2 ) noexcept
{
   return s2.CompareCodePoints( t1 ) == 0;
}
 
inline bool operator  <( const char16_t* t1, const String& s2 ) noexcept
{
   return s2.CompareCodePoints( t1 ) > 0;
}
 
inline bool operator <=( const char16_t* t1, const String& s2 ) noexcept
{
   return s2.CompareCodePoints( t1 ) >= 0;
}
 
inline bool operator  >( const char16_t* t1, const String& s2 ) noexcept
{
   return s2.CompareCodePoints( t1 ) < 0;
}
 
inline bool operator >=( const char16_t* t1, const String& s2 ) noexcept
{
   return s2.CompareCodePoints( t1 ) <= 0;
}
 
// ----------------------------------------------------------------------------
 
inline bool operator ==( const String& s1, char16_t c2 ) noexcept
{
   return s1.CompareCodePoints( c2 ) == 0;
}
 
inline bool operator  <( const String& s1, char16_t c2 ) noexcept
{
   return s1.CompareCodePoints( c2 ) < 0;
}
 
inline bool operator <=( const String& s1, char16_t c2 ) noexcept
{
   return s1.CompareCodePoints( c2 ) <= 0;
}
 
inline bool operator  >( const String& s1, char16_t c2 ) noexcept
{
   return s1.CompareCodePoints( c2 ) > 0;
}
 
inline bool operator >=( const String& s1, char16_t c2 ) noexcept
{
   return s1.CompareCodePoints( c2 ) >= 0;
}
 
// ----------------------------------------------------------------------------
 
inline bool operator ==( char16_t c1, const String& s2 ) noexcept
{
   return s2.CompareCodePoints( c1 ) == 0;
}
 
inline bool operator  <( char16_t c1, const String& s2 ) noexcept
{
   return s2.CompareCodePoints( c1 ) > 0;
}
 
inline bool operator <=( char16_t c1, const String& s2 ) noexcept
{
   return s2.CompareCodePoints( c1 ) >= 0;
}
 
inline bool operator  >( char16_t c1, const String& s2 ) noexcept
{
   return s2.CompareCodePoints( c1 ) < 0;
}
 
inline bool operator >=( char16_t c1, const String& s2 ) noexcept
{
   return s2.CompareCodePoints( c1 ) <= 0;
}
 
// ----------------------------------------------------------------------------
 
inline bool operator ==( const String& s1, const wchar_t* t2 ) noexcept
{
   return s1.CompareCodePoints( t2 ) == 0;
}
 
inline bool operator  <( const String& s1, const wchar_t* t2 ) noexcept
{
   return s1.CompareCodePoints( t2 ) < 0;
}
 
inline bool operator <=( const String& s1, const wchar_t* t2 ) noexcept
{
   return s1.CompareCodePoints( t2 ) <= 0;
}
 
inline bool operator  >( const String& s1, const wchar_t* t2 ) noexcept
{
   return s1.CompareCodePoints( t2 ) > 0;
}
 
inline bool operator >=( const String& s1, const wchar_t* t2 ) noexcept
{
   return s1.CompareCodePoints( t2 ) >= 0;
}
 
// ----------------------------------------------------------------------------
 
inline bool operator ==( const wchar_t* t1, const String& s2 ) noexcept
{
   return s2.CompareCodePoints( t1 ) == 0;
}
 
inline bool operator  <( const wchar_t* t1, const String& s2 ) noexcept
{
   return s2.CompareCodePoints( t1 ) > 0;
}
 
inline bool operator <=( const wchar_t* t1, const String& s2 ) noexcept
{
   return s2.CompareCodePoints( t1 ) >= 0;
}
 
inline bool operator  >( const wchar_t* t1, const String& s2 ) noexcept
{
   return s2.CompareCodePoints( t1 ) < 0;
}
 
inline bool operator >=( const wchar_t* t1, const String& s2 ) noexcept
{
   return s2.CompareCodePoints( t1 ) <= 0;
}
 
// ----------------------------------------------------------------------------
 
inline bool operator ==( const String& s1, wchar_t c2 ) noexcept
{
   return s1.CompareCodePoints( c2 ) == 0;
}
 
inline bool operator  <( const String& s1, wchar_t c2 ) noexcept
{
   return s1.CompareCodePoints( c2 ) < 0;
}
 
inline bool operator <=( const String& s1, wchar_t c2 ) noexcept
{
   return s1.CompareCodePoints( c2 ) <= 0;
}
 
inline bool operator  >( const String& s1, wchar_t c2 ) noexcept
{
   return s1.CompareCodePoints( c2 ) > 0;
}
 
inline bool operator >=( const String& s1, wchar_t c2 ) noexcept
{
   return s1.CompareCodePoints( c2 ) >= 0;
}
 
// ----------------------------------------------------------------------------
 
inline bool operator ==( wchar_t c1, const String& s2 ) noexcept
{
   return s2.CompareCodePoints( c1 ) == 0;
}
 
inline bool operator  <( wchar_t c1, const String& s2 ) noexcept
{
   return s2.CompareCodePoints( c1 ) > 0;
}
 
inline bool operator <=( wchar_t c1, const String& s2 ) noexcept
{
   return s2.CompareCodePoints( c1 ) >= 0;
}
 
inline bool operator  >( wchar_t c1, const String& s2 ) noexcept
{
   return s2.CompareCodePoints( c1 ) < 0;
}
 
inline bool operator >=( wchar_t c1, const String& s2 ) noexcept
{
   return s2.CompareCodePoints( c1 ) <= 0;
}
 
// ----------------------------------------------------------------------------
 
inline bool operator ==( const String& s1, String::const_c_string8 t2 ) noexcept
{
   return s1.CompareCodePoints( t2 ) == 0;
}
 
inline bool operator  <( const String& s1, String::const_c_string8 t2 ) noexcept
{
   return s1.CompareCodePoints( t2 ) < 0;
}
 
inline bool operator <=( const String& s1, String::const_c_string8 t2 ) noexcept
{
   return s1.CompareCodePoints( t2 ) <= 0;
}
 
inline bool operator  >( const String& s1, String::const_c_string8 t2 ) noexcept
{
   return s1.CompareCodePoints( t2 ) > 0;
}
 
inline bool operator >=( const String& s1, String::const_c_string8 t2 ) noexcept
{
   return s1.CompareCodePoints( t2 ) >= 0;
}
 
// ----------------------------------------------------------------------------
 
inline bool operator ==( String::const_c_string8 t1, const String& s2 ) noexcept
{
   return s2.CompareCodePoints( t1 ) == 0;
}
 
inline bool operator  <( String::const_c_string8 t1, const String& s2 ) noexcept
{
   return s2.CompareCodePoints( t1 ) > 0;
}
 
inline bool operator <=( String::const_c_string8 t1, const String& s2 ) noexcept
{
   return s2.CompareCodePoints( t1 ) >= 0;
}
 
inline bool operator  >( String::const_c_string8 t1, const String& s2 ) noexcept
{
   return s2.CompareCodePoints( t1 ) < 0;
}
 
inline bool operator >=( String::const_c_string8 t1, const String& s2 ) noexcept
{
   return s2.CompareCodePoints( t1 ) <= 0;
}
 
// ----------------------------------------------------------------------------
 
inline bool operator ==( const String& s1, String::char8_type c2 ) noexcept
{
   return s1.CompareCodePoints( c2 ) == 0;
}
 
inline bool operator  <( const String& s1, String::char8_type c2 ) noexcept
{
   return s1.CompareCodePoints( c2 ) < 0;
}
 
inline bool operator <=( const String& s1, String::char8_type c2 ) noexcept
{
   return s1.CompareCodePoints( c2 ) <= 0;
}
 
inline bool operator  >( const String& s1, String::char8_type c2 ) noexcept
{
   return s1.CompareCodePoints( c2 ) > 0;
}
 
inline bool operator >=( const String& s1, String::char8_type c2 ) noexcept
{
   return s1.CompareCodePoints( c2 ) >= 0;
}
 
// ----------------------------------------------------------------------------
 
inline bool operator ==( String::char8_type c1, const String& s2 ) noexcept
{
   return s2.CompareCodePoints( c1 ) == 0;
}
 
inline bool operator  <( String::char8_type c1, const String& s2 ) noexcept
{
   return s2.CompareCodePoints( c1 ) > 0;
}
 
inline bool operator <=( String::char8_type c1, const String& s2 ) noexcept
{
   return s2.CompareCodePoints( c1 ) >= 0;
}
 
inline bool operator  >( String::char8_type c1, const String& s2 ) noexcept
{
   return s2.CompareCodePoints( c1 ) < 0;
}
 
inline bool operator >=( String::char8_type c1, const String& s2 ) noexcept
{
   return s2.CompareCodePoints( c1 ) <= 0;
}
 
// ----------------------------------------------------------------------------
 
#ifndef __PCL_NO_STRING_OSTREAM
 
inline std::wostream& operator <<( std::wostream& o, const String& s )
{
#ifdef __PCL_WINDOWS
   return o << reinterpret_cast<const wchar_t*>( s.c_str() );
#else
   Array<wchar_t> w = s.ToWCharArray();
   return o << w.Begin();
#endif
}
 
inline std::ostream& operator <<( std::ostream& o, const String& s )
{
   return o << s.ToUTF8();
}
 
#endif   // __PCL_NO_STRING_OSTREAM
 
// ----------------------------------------------------------------------------
 
} // pcl
 
#endif   // __PCL_String_h
 
// ----------------------------------------------------------------------------
// EOF pcl/String.h - Released 2024-01-13T15:47:58Z