vlUnicodeChar.h

Go to the documentation of this file.

/****************************************************************************
 * Copyright (c) 1992-2025 MAK Technologies, Inc
 * All rights reserved.
 ****************************************************************************/


#pragma once

#include <stdexcept>

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;

   // 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;

public:

   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;
   }

   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
   {
      return ( (myCodePoint>0xFFFF)? 4 : 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
   {
      return ( (myCodePoint>=0x10000)? 2 : 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;
      }

      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;
      }

      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();
}

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


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 void DtUnicodeChar::writeWChar( wchar_t* memory ) const
{
   writeWCharT<sizeof(wchar_t)>( memory );
}