vlUnicode.h

Go to the documentation of this file.

/****************************************************************************
 * Copyright (c) 2014 VT MAK
 * All rights reserved.
 ****************************************************************************/


#pragma once

#include <vlutil/vlUnicodeChar.h>

#include <wchar.h>

class DtUcString
{
public:

   typedef unsigned short CodeUnit;

public:

   inline DtUcString();

   explicit inline DtUcString( size_t len, DtUnicodeChar c = DtUnicodeChar('\0') );

   inline DtUcString( const DtUcString& str );

   inline ~DtUcString();

   inline DtUcString& operator = ( const DtUcString& str );

   inline static DtUcString fromWCharArray( const wchar_t utf16[], int len = -1 );

   inline static DtUcString fromWideString( const std::wstring& str );

   inline static DtUcString fromUtf8( const unsigned char* utf8, int len = -1 );
   inline static DtUcString fromUtf8( const std::string& utf8 );

   inline static DtUcString fromUtf16( const unsigned short* utf16, int len = -1 );

   inline static DtUcString fromUtf32( const unsigned int* utf32, int len = -1 );

   inline static DtUcString fromAscii( const std::string& ascii );

   inline static DtUcString fromAscii( const char* ascii, int len = -1 );

   inline static DtUcString tr( const char* ascii );

   template <typename QStringType, typename QCoreApp>
   QStringType translate() const;

   template <typename QStringType>
   inline static DtUcString fromQString( QStringType qstr );

   inline void setFromWCharArray( const wchar_t utf16[], int len = -1 );

   inline void setFromUtf8( const unsigned char* utf8, int len = -1 );
   inline void setFromUtf8( const std::string& utf8 );

   inline void setFromLatin1( const char* latin, int len = -1 );

   inline void setFromUtf16( const unsigned short* utf16, int len = -1 );

   inline void setFromUtf32( const unsigned int* utf32, int len = -1 );

   inline void setFromAscii( const std::string& ascii );

   inline void setFromAscii( const char* ascii, int len = -1 );

   template <typename QStringType>
   inline void setFromQString( QStringType qstr );

   inline void toAscii( std::string& str ) const;
   inline std::string toAscii() const;

   inline void toLatin1( std::string& str ) const;
   inline std::string toLatin1() const;

   inline void toUtf8( std::string& str ) const;
   inline std::string toUtf8() const;

   inline void toWideString( std::wstring& str ) const;
   inline std::wstring toWideString() const;

   template <typename QStringType>
   inline QStringType toQString() const;

   template <typename QStringType>
   inline void toQString( QStringType& qstr ) const;

   inline DtUcString& operator += ( const DtUcString& str );
   inline DtUcString& operator += ( const DtUnicodeChar& x );
   inline DtUcString operator + ( const DtUcString& str ) const;

   inline bool operator == ( const DtUcString& other ) const;
   inline bool operator != ( const DtUcString& other ) const;
   inline bool operator < ( const DtUcString& other ) const;

   inline size_t length() const;

   inline size_t sizeInBytes() const;

   inline size_t calculateCodePoints() const;

   inline const CodeUnit* codeUnits() const;

   inline int indexOf( const DtUnicodeChar& x, size_t pos = 0 ) const;

   inline int indexOf( const DtUcString& x, size_t pos = 0 ) const;

   inline int lastIndexOf( const DtUnicodeChar& x, size_t pos = 0 ) const;

   inline int lastIndexOf( const DtUcString& x, size_t pos = 0 ) const;

   inline DtUcString subString( size_t pos = 0, int len = -1 ) const;


   virtual bool snipFront( const char ch, bool toLastCh = false );
   virtual bool snipBack( const char ch, bool fromFirstCh = false );


   inline void push_back( const DtUnicodeChar& x );

   inline void resize( int size );

protected: // THESE are the protected functions not to be used directly.

   enum Encoding
   {
      Ascii,
      Latin1,
      Utf8
   };

   // Ascii CTOR
   inline explicit DtUcString( const char* ascii, int len = -1, Encoding encoding = Ascii );

   // UTF16 constructor
   inline explicit DtUcString( const unsigned short* utf16, int len = -1 );

   // UTF32 constructor.
   inline explicit DtUcString( const unsigned int* utf32, int len = -1 );

   // Std string constructor.
   inline explicit DtUcString( const std::string& ascii );

   // Concat constructor.
   inline explicit DtUcString( const DtUcString& a, const DtUcString& b );

protected:

   struct CodeUnitArray
   {

      inline CodeUnitArray();

      inline CodeUnitArray( const CodeUnitArray& );

      inline ~CodeUnitArray();

      inline CodeUnitArray& operator = ( const CodeUnitArray& );

      inline void resize( size_t newSize );

      inline void clear();

      inline void reserve( size_t capacity );

      inline size_t calculateCapacity( size_t necessarySize );

      inline size_t size() const;

      inline size_t capacity() const;

      inline void concat( const CodeUnitArray& other );

      inline bool unique() const;

      inline bool empty() const;

      inline void add_ref();

      inline void dec_ref();

      volatile long* count;
      CodeUnit* begin;
      CodeUnit* end;
      CodeUnit* last;

   };

   CodeUnitArray myCodeUnits;

};


inline std::size_t hash_value( const DtUcString& val )
{
   // Copied from TR1 implementation.
   size_t seed = 2166136261U;
   size_t first = 0;
   size_t last = val.length();
   size_t stride = 1 + last / 10;

   if ( stride < last )
   {
      last -= stride;
   }
   for ( ; first < last; first += stride )
   {
      seed = 16777619U * seed ^ (size_t)val.codeUnits()[first];
   }

   return seed;
}


#include "vlUnicode.inl"