DtUnicodeChar.h

Go to the documentation of this file.

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


#ifndef DtUnicodeChar_H
#define DtUnicodeChar_H

#include <stdexcept>

namespace makVrv
{
   class DtUnicodeChar
   {
   public:

      //A Unicode Code Point, is a unique Unicode Character. 
      typedef unsigned int CodePoint;

      //A Unicode Surrogate code point, is a 16bit code point, used in UTF-16 encoding.
      typedef unsigned short Surrogate;

      typedef unsigned char Octet;

      inline DtUnicodeChar()
      : myCodePoint(0)
      {
      }

      inline explicit DtUnicodeChar(const char c)
      : myCodePoint(c)
      {
      }


      inline explicit DtUnicodeChar(const wchar_t c)
      : myCodePoint(c)
      {
      }

      inline explicit DtUnicodeChar(const unsigned short s,const unsigned short c)
      : myCodePoint( decodeSurrogatePair(s,c) )
      {
         if(!(isSurrogate(s) && isSurrogate(c)))
         {
            throw std::invalid_argument("UTF-16 characters are not a surrogate pair.");
         }
      }

      inline DtUnicodeChar(const DtUnicodeChar& other)
      : myCodePoint(other.myCodePoint)
      {
      }

      template <int sizeof_wchar_t>
      inline static CodePoint widechar(const wchar_t c);      

      inline DtUnicodeChar& operator=(const DtUnicodeChar& other)   
      {
         //No need to check for equality.
         myCodePoint = other.myCodePoint;
         return *this;
      }

      inline bool operator==(const DtUnicodeChar& other) const
      {
         return myCodePoint == other.myCodePoint;
      }

      inline bool operator!=(const DtUnicodeChar& other) const
      {
         return myCodePoint != other.myCodePoint;
      }

      // Maximum valid value for a Unicode code point
      static const CodePoint CodePointMax = 0x0010ffff;
      static const Surrogate LeadSurrogateMin = 0xd800;
      static const Surrogate LeadSurrogateMax = 0xdbff;
      static const Surrogate TrailSurrogateMin = 0xdc00;
      static const Surrogate TrailSurrogateMax = 0xdfff;

      static inline bool isCodePointValid(CodePoint codePoint)
      {
         return (codePoint <= CodePointMax && !isSurrogate((Surrogate)codePoint) && 
            codePoint != 0xfffe && codePoint != 0xffff);      
      }

      static inline bool isSurrogateSubstringValid(const Surrogate* start,  
         const Surrogate* end, const Surrogate* substringStart, 
         const Surrogate* substringEnd) 
      {
         // Test to see if beginning in middle of surrogate pair.
         if(TrailSurrogateMin == ((*substringStart)&0xfffffc00) && 
            start != substringStart && 
            LeadSurrogateMin  == ((*(substringStart - 1))&0xfffffc00))
         {

            return false;
         }

         //Test to see if end is middle of pair.
         if((LeadSurrogateMin  == ((*(substringEnd - 1 ))&0xfffffc00)) &&
            substringStart != end && 
            (TrailSurrogateMin == ((*substringEnd)&0xfffffc00)))
         {
            return false;
         }

         //Not at middle of surrogate pair.
         return true;
      }


      static inline bool isSurrogate(Surrogate cp)
      {
         return (cp >= LeadSurrogateMin && cp <= TrailSurrogateMax);
      }

      static inline DtUnicodeChar fromUtf32(unsigned int character)
      {
         if(!isCodePointValid(character)) throw std::invalid_argument("Not a valid UTF 32 code point");
         return DtUnicodeChar(character);
      }

      inline unsigned int utf8Length() const
      {
         if (myCodePoint < 0x80)  // one octet
         {
            return 1;
         }
         else if (myCodePoint < 0x800) // two octets
         {
            return 2;
         }
         else if (myCodePoint < 0x10000) // three octets
         {
            return 3;
         }
         else // four octets
         {
            return 4;
         }
      }

      template <int sizeofWChar_t>
      inline unsigned int wchartLength() const;

      inline unsigned int wideStringLength() const;      

      inline unsigned int utf16Length() const
      {
         if(myCodePoint > 0xFFFF) return 4; else return 2;
      }

      inline unsigned int utf32Length() const
      {
         return 4;
      }

      static inline CodePoint decodeSurrogatePair(Surrogate hi,Surrogate lo)
      {
         //Get bits 10 - 15 bits from hi, and get bits 0-9 bits from lo
         CodePoint X = (hi & 0x3F) << 10 | (lo & 0x3FF);
         //Get bits 16-21 from hi, and offset.
         CodePoint U = ((hi >> 6) & (0x1F)) + 1;
         //Recombine.
         return (U << 16) | X;
      }

      static inline void encodeSurrogatePair(CodePoint cp, Surrogate& hi,Surrogate& lo)
      {      
         //   TAG                Top 17-22 bits minus 1,               
         hi = LeadSurrogateMin | ((unsigned short)((cp >> 16) & 0x1F) - 1)  
                               // bits 10-16 bits.
                               | (unsigned short)((cp >> 10) & 0x3F);
         //Has bottom 10 bits + Trail Tag.
         lo = TrailSurrogateMin | (unsigned short)(cp & 0x3FF);
      }

      inline unsigned int utf16CodeUnits() const
      {
         if(myCodePoint >= 0x10000)
         {
            return 2;
         }
         else
         {
            return 1;
         }
      }

      inline unsigned int readUtf16(const Surrogate* memory)
      {
         if(isSurrogate(*memory))
         {
            Surrogate hiPair = *memory;
            Surrogate loPair = *(memory + 1);
            myCodePoint = decodeSurrogatePair(hiPair,loPair);
            return 2;
         }
         else
         {
            myCodePoint = *memory;
            return 1;
         }
      }

      inline void writeUtf16(Surrogate* memory) const
      {
         if(myCodePoint >= 0x10000)
         {
            encodeSurrogatePair(myCodePoint,*memory,*(memory + 1));
         }
         else
         {
            *memory = static_cast<Surrogate>(myCodePoint);
         }
      }

      inline void readUtf32(const unsigned int* memory)
      {
         myCodePoint = *memory;
      }

      inline void writeUtf32(unsigned int* memory) const
      {
         *memory = myCodePoint;
      }

      static inline unsigned int utf8Length(const unsigned char c)
      {
         if(c < 0x80)
         {
            return 1;
         }
         else if(c < 0xE0)
         {
            return 2;
         }
         else if(c < 0xF0)
         {
            return 3;
         }
         else if(c < 0xF8)
         {
            return 4;
         }
         else
         {
            throw std::invalid_argument("Not a valid UTF8 string.");
         }
      }

      inline unsigned int readUtf8(const unsigned char* memory)
      {
         unsigned char c = *memory;
         if(c < 0x80)
         {
            myCodePoint = c;
            return 1;
         }
         else if(c < 0xE0)
         {
            myCodePoint = ((c & 0x1F) << 6) | 
                          (*(memory + 1) & 0x3F);
            return 2;
         }
         else if(c < 0xF0)
         {
            myCodePoint = ((c & 0xF) << 12) | 
                          ((*(memory + 1) & 0x3F) << 6) |
                           (*(memory + 2) & 0x3F);
            return 3;
         }
         else if(c < 0xF8)
         {
            myCodePoint = ((c & 0x7) << 18) | 
                          ((*(memory + 1) & 0x3F) << 12) | 
                          ((*(memory + 2) & 0x3F) << 6) |
                           (*(memory + 3) & 0x3F);
            return 4;
         }
         else
         {
            throw std::invalid_argument("Not a valid UTF8 string.");
         }
      }

      inline void writeUtf8(char* memory) const
      {
         if (myCodePoint < 0x80)  // one octet
         {
            *memory = (unsigned char)(myCodePoint & 0x7F);
         }
         else if (myCodePoint < 0x800) // two octets
         {         
            *memory     = (unsigned char)((myCodePoint >> 6) & 0x1F) | 0xC0;
            *(memory+1) = (unsigned char)((myCodePoint     ) & 0x3F) | 0x80;

         }
         else if (myCodePoint < 0x10000) // three octets
         {
            *memory     = (unsigned char)((myCodePoint >> 12) & 0xF ) | 0xE0;
            *(memory+1) = (unsigned char)((myCodePoint >> 6)  & 0x3F) | 0x80;
            *(memory+2) = (unsigned char)((myCodePoint     )  & 0x3F) | 0x80;
         }
         else // four octets
         {
            *memory     = (unsigned char)((myCodePoint >> 18) & 0x7 ) | 0xF0;
            *(memory+1) = (unsigned char)((myCodePoint >> 12) & 0x3F) | 0x80;
            *(memory+2) = (unsigned char)((myCodePoint >> 6 ) & 0x3F) | 0x80;
            *(memory+3) = (unsigned char)((myCodePoint      ) & 0x3F) | 0x80;
         }
      }

      template <int sizeofWchart>
      inline void writeWCharT(wchar_t* memory) const;


      inline void writeWChar(wchar_t* memory) const;

      inline CodePoint codePoint() const
      {
         return myCodePoint;
      }

   protected:

      inline DtUnicodeChar(unsigned int utf32c) 
      : myCodePoint(utf32c)
      {
      }

   private:
      CodePoint myCodePoint;
   };

      template <>
      inline unsigned int DtUnicodeChar::wchartLength<2>() const
      {
         return utf16CodeUnits() << 1;
      }

      template <>
      inline unsigned int DtUnicodeChar::wchartLength<4>() const
      {
         return utf32Length();
      }

 

   template <int sizeof_wchar_t>
   inline DtUnicodeChar::CodePoint DtUnicodeChar::widechar(const wchar_t c)
   {
      return c;
   }

   template <>
   inline DtUnicodeChar::CodePoint DtUnicodeChar::widechar<2>(const wchar_t c)
   {
      if(isSurrogate(c))
      {
         throw std::invalid_argument("Invalid UTF-16 character");
      }
      return c;      
   }

   template <>
   inline void DtUnicodeChar::writeWCharT<2>(wchar_t* memory) const
   {
      writeUtf16(reinterpret_cast<Surrogate*>(memory));
   }

   template <>
   inline void DtUnicodeChar::writeWCharT<4>(wchar_t* memory) const
   {
      writeUtf32(reinterpret_cast<unsigned int*>(memory));
   }

   inline unsigned int DtUnicodeChar::wideStringLength() const
   {
      return wchartLength<sizeof(wchar_t)>();
   }

   inline void DtUnicodeChar::writeWChar(wchar_t* memory) const
   {         
      writeWCharT<sizeof(wchar_t)>(memory);
   }
}

#endif