include/vrvUtil/DtUnicode.h

Go to the documentation of this file.

/****************************************************************************** 
** Copyright (c) 2010 MAK Technologies, Inc. 
** All rights reserved. 
******************************************************************************/ 
/*********************************************************************
** $RCSfile: DtUnicode.h,v $ $Revision: $ $State: $
*********************************************************************/


#pragma once

#include <wchar.h>
#include <vrvUtil/DtUnicodeChar.h>
#include <boost/functional/hash.hpp>
#include <boost/serialization/split_free.hpp>

namespace makVrv
{

   class DtUnicode
   {
   public:
      typedef unsigned short CodeUnit;

      inline DtUnicode();
      
      inline ~DtUnicode();

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

      inline DtUnicode(const DtUnicode& str);

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


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

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

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

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

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

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

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

      inline static DtUnicode tr(const char* ascii)
      {
         return fromAscii(ascii);
      }

      template <typename QStringType, typename QCoreApp>
      QStringType translate() const
      {
         return QCoreApp::translate("makVrv::DtUnicode",toUtf8().c_str(),
            0, QCoreApp::UnicodeUTF8);
      }

      template <typename QStringType>
      inline static DtUnicode fromQString(QStringType qstr) 
      { 
         return fromUtf16(qstr.utf16(),qstr.length()); 
      }


      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) 
      { 
         setFromUtf16(qstr.utf16(),qstr.length());
      }


      inline void toAscii(std::string& str) const;
      inline std::string toAscii() const { std::string temp; toAscii(temp); return temp;}

      inline void toLatin1(std::string& str) const;
      inline std::string toLatin1() const { std::string temp; toLatin1(temp); return temp;}

      inline void toUtf8(std::string& str) const;
      inline std::string toUtf8() const { std::string temp; toUtf8(temp); return temp;}
      inline void toWideString(std::wstring& str) const;
      inline std::wstring toWideString() const { std::wstring temp; toWideString(temp); return temp;}
      
      template <typename QStringType>
      inline QStringType toQString() const
      { 
         return QStringType::fromUtf16(codeUnits(),length()); 
      }

      template <typename QStringType>
      inline void toQString(QStringType& qstr) const
      { 
         qstr.setUtf16(codeUnits(),length()); 
      }

      inline DtUnicode& operator+=(const DtUnicode& str);
      inline DtUnicode& operator+=(const DtUnicodeChar& x);
      inline DtUnicode operator+(const DtUnicode& str) const;
      
      inline bool operator==(const DtUnicode& other) const;
      inline bool operator!=(const DtUnicode& other) const;
      inline bool operator<(const DtUnicode& other) const;

      inline size_t length() const;

      inline size_t sizeInBytes() const { return length() << 1; }

      inline size_t calculateCodePoints() const;

      inline const CodeUnit* codeUnits() const { return myCodeUnits.begin; }

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

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

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

      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 DtUnicode(const char* ascii, int len = -1,Encoding encoding = Ascii);

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

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

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

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

   protected:

      struct CodeUnitArray
      {
         inline CodeUnitArray();
         inline CodeUnitArray(const CodeUnitArray&);
         inline CodeUnitArray& operator=(const CodeUnitArray&);
         inline ~CodeUnitArray();

         inline void resize(size_t newSize);

         inline void clear();

         inline void reserve(size_t capacity);

         //Calculate the capacity
         inline size_t calculateCapacity(size_t necessarySize);

         //Return size in bytes
         inline size_t size() const;

         //Return capacity in bytes
         inline size_t capacity() const;

         //Concat another array, supports concat operations on itself.
         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;
   };
}

//Allows DtUnicode to be used in boost hash containers.
namespace makVrv
{
   inline std::size_t hash_value(DtUnicode const& 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 "DtUnicode.inl"