EIC code displayed by LXR master/​include/​opencascade/​NCollection_UtfString.hxx	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-01-18 10:04:20

 // Created on: 2013-01-28
 // Created by: Kirill GAVRILOV
 // Copyright (c) 2013-2014 OPEN CASCADE SAS
 //
 // This file is part of Open CASCADE Technology software library.
 //
 // This library is free software; you can redistribute it and/or modify it under
 // the terms of the GNU Lesser General Public License version 2.1 as published
 // by the Free Software Foundation, with special exception defined in the file
 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
 // distribution for complete text of the license and disclaimer of any warranty.
 //
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
 #ifndef NCollection_UtfString_HeaderFile
 #define NCollection_UtfString_HeaderFile
 
 #include <NCollection_UtfIterator.hxx>
 
 #include <cstring>
 #include <cstdlib>
 
 //! This template class represent constant UTF-* string.
 //! String stored in memory continuously, always NULL-terminated
 //! and can be used as standard C-string using ToCString() method.
 //!
 //! Notice that changing the string is not allowed
 //! and any modifications should produce new string.
 //!
 //! In comments to this class, terms "Unicode symbol" is used as 
 //! synonym of "Unicode code point".
 template<typename Type>
 class NCollection_UtfString
 {
 
 public:
 
   NCollection_UtfIterator<Type> Iterator() const
   {
     return NCollection_UtfIterator<Type> (myString);
   }
 
   //! @return the size of the buffer in bytes, excluding NULL-termination symbol
   Standard_Integer Size() const
   {
     return mySize;
   }
 
   //! @return the length of the string in Unicode symbols
   Standard_Integer Length() const
   {
     return myLength;
   }
 
   //! Retrieve Unicode symbol at specified position.
   //! Warning! This is a slow access. Iterator should be used for consecutive parsing.
   //! @param theCharIndex the index of the symbol, should be lesser than Length()
   //! @return the Unicode symbol value
   Standard_Utf32Char GetChar (const Standard_Integer theCharIndex) const;
 
   //! Retrieve string buffer at specified position.
   //! Warning! This is a slow access. Iterator should be used for consecutive parsing.
   //! @param theCharIndex the index of the symbol, should be less than Length()
   //!        (first symbol of the string has index 0)
   //! @return the pointer to the symbol
   const Type* GetCharBuffer (const Standard_Integer theCharIndex) const;
 
   //! Retrieve Unicode symbol at specified position.
   //! Warning! This is a slow access. Iterator should be used for consecutive parsing.
   Standard_Utf32Char operator[] (const Standard_Integer theCharIndex) const
   {
     return GetChar (theCharIndex);
   }
 
   //! Initialize empty string.
   NCollection_UtfString();
 
   //! Copy constructor.
   //! @param theCopy string to copy.
   NCollection_UtfString (const NCollection_UtfString& theCopy);
 
   //! Move constructor
   NCollection_UtfString (NCollection_UtfString&& theOther);
 
   //! Copy constructor from UTF-8 string.
   //! @param theCopyUtf8 UTF-8 string to copy
   //! @param theLength   optional length limit in Unicode symbols (NOT bytes!)
   //! The string is copied till NULL symbol or, if theLength >0, 
   //! till either NULL or theLength-th symbol (which comes first).
   NCollection_UtfString (const char*            theCopyUtf8,
                          const Standard_Integer theLength = -1);
 
   //! Copy constructor from UTF-16 string.
   //! @param theCopyUtf16 UTF-16 string to copy
   //! @param theLength    the length limit in Unicode symbols (NOT bytes!)
   //! The string is copied till NULL symbol or, if theLength >0, 
   //! till either NULL or theLength-th symbol (which comes first).
   NCollection_UtfString (const Standard_Utf16Char* theCopyUtf16,
                          const Standard_Integer    theLength = -1);
 
   //! Copy constructor from UTF-32 string.
   //! @param theCopyUtf32 UTF-32 string to copy
   //! @param theLength    the length limit in Unicode symbols (NOT bytes!)
   //! The string is copied till NULL symbol or, if theLength >0, 
   //! till either NULL or theLength-th symbol (which comes first).
   NCollection_UtfString (const Standard_Utf32Char* theCopyUtf32,
                          const Standard_Integer    theLength = -1);
 
 #if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED) || (defined(_MSC_VER) && _MSC_VER >= 1900)
   //! Copy constructor from wide UTF string.
   //! @param theCopyUtfWide wide UTF string to copy
   //! @param theLength      the length limit in Unicode symbols (NOT bytes!)
   //! The string is copied till NULL symbol or, if theLength >0, 
   //! till either NULL or theLength-th symbol (which comes first).
   //!
   //! This constructor is undefined if Standard_WideChar is the same type as Standard_Utf16Char.
   NCollection_UtfString (const Standard_WideChar* theCopyUtfWide,
                          const Standard_Integer   theLength = -1);
 #endif
 
   //! Copy from Unicode string in UTF-8, UTF-16, or UTF-32 encoding,
   //! determined by size of TypeFrom character type.
   //! @param theStringUtf Unicode string
   //! @param theLength    the length limit in Unicode symbols
   //! The string is copied till NULL symbol or, if theLength >0, 
   //! till either NULL or theLength-th symbol (which comes first).
   template <typename TypeFrom>
   inline void FromUnicode (const TypeFrom*        theStringUtf,
                            const Standard_Integer theLength = -1)
   {
     NCollection_UtfIterator<TypeFrom> anIterRead (theStringUtf);
     if (*anIterRead == 0)
     {
       // special case
       Clear();
       return;
     }
     fromUnicodeImpl (theStringUtf, theLength, anIterRead);
   }
 
   //! Copy from multibyte string in current system locale.
   //! @param theString multibyte string
   //! @param theLength the length limit in Unicode symbols
   //! The string is copied till NULL symbol or, if theLength >0, 
   //! till either NULL or theLength-th symbol (which comes first).
   void FromLocale (const char*            theString,
                    const Standard_Integer theLength = -1);
 
   //! Destructor.
   ~NCollection_UtfString();
 
   //! Compares this string with another one.
   bool IsEqual (const NCollection_UtfString& theCompare) const;
 
   //! Returns the substring.
   //! @param theStart start index (inclusive) of subString
   //! @param theEnd   end index   (exclusive) of subString
   //! @return the substring
   NCollection_UtfString SubString (const Standard_Integer theStart,
                                    const Standard_Integer theEnd) const;
 
   //! Returns NULL-terminated Unicode string.
   //! Should not be modified or deleted!
   //! @return (const Type* ) pointer to string
   const Type* ToCString() const
   {
     return myString;
   }
 
   //! @return copy in UTF-8 format
   const NCollection_UtfString<Standard_Utf8Char> ToUtf8() const;
 
   //! @return copy in UTF-16 format
   const NCollection_UtfString<Standard_Utf16Char> ToUtf16() const;
 
   //! @return copy in UTF-32 format
   const NCollection_UtfString<Standard_Utf32Char> ToUtf32() const;
 
   //! @return copy in wide format (UTF-16 on Windows and UTF-32 on Linux)
   const NCollection_UtfString<Standard_WideChar> ToUtfWide() const;
 
   //! Converts the string into string in the current system locale.
   //! @param theBuffer    output buffer
   //! @param theSizeBytes buffer size in bytes
   //! @return true on success
   bool ToLocale (char*                  theBuffer,
                  const Standard_Integer theSizeBytes) const;
 
   //! @return true if string is empty
   bool IsEmpty() const
   {
     return myString[0] == Type(0);
   }
 
   //! Zero string.
   void Clear();
 
 public: //! @name assign operators
 
   //! Copy from another string.
   const NCollection_UtfString& Assign (const NCollection_UtfString& theOther);
 
   //! Exchange the data of two strings (without reallocating memory).
   void Swap (NCollection_UtfString& theOther);
 
   //! Copy from another string.
   const NCollection_UtfString& operator= (const NCollection_UtfString& theOther) { return Assign (theOther); }
 
   //! Move assignment operator.
   NCollection_UtfString& operator= (NCollection_UtfString&& theOther) { Swap (theOther); return *this; }
 
   //! Copy from UTF-8 NULL-terminated string.
   const NCollection_UtfString& operator= (const char* theStringUtf8);
 
   //! Copy from wchar_t UTF NULL-terminated string.
   const NCollection_UtfString& operator= (const Standard_WideChar* theStringUtfWide);
 
   //! Join strings.
   NCollection_UtfString& operator+= (const NCollection_UtfString& theAppend);
 
   //! Join two strings.
   friend NCollection_UtfString operator+ (const NCollection_UtfString& theLeft,
                                           const NCollection_UtfString& theRight)
   {
     NCollection_UtfString aSumm;
     strFree (aSumm.myString);
     aSumm.mySize   = theLeft.mySize   + theRight.mySize;
     aSumm.myLength = theLeft.myLength + theRight.myLength;
     aSumm.myString = strAlloc (aSumm.mySize);
 
     // copy bytes
     strCopy ((Standard_Byte* )aSumm.myString,                  (const Standard_Byte* )theLeft.myString,  theLeft.mySize);
     strCopy ((Standard_Byte* )aSumm.myString + theLeft.mySize, (const Standard_Byte* )theRight.myString, theRight.mySize);
     return aSumm;
   }
 
 public: //! @name compare operators
 
   bool operator== (const NCollection_UtfString& theCompare) const
   {
     return IsEqual (theCompare);
   }
   bool operator!= (const NCollection_UtfString& theCompare) const;
 
 private: //! @name low-level methods
 
   //! Implementation of copy routine for string of the same type
   void fromUnicodeImpl (const Type* theStringUtf, const Standard_Integer theLength, NCollection_UtfIterator<Type>& theIterator)
   {
     Type* anOldBuffer = myString; // necessary in case of self-copying
 
     // advance to the end
     const Standard_Integer aLengthMax = (theLength > 0) ? theLength : IntegerLast();
     for(; *theIterator != 0 && theIterator.Index() < aLengthMax; ++theIterator) {}
 
     mySize   = Standard_Integer((Standard_Byte* )theIterator.BufferHere() - (Standard_Byte* )theStringUtf);
     myLength = theIterator.Index();
     myString = strAlloc (mySize);
     strCopy ((Standard_Byte* )myString, (const Standard_Byte* )theStringUtf, mySize);
 
     strFree (anOldBuffer);
   }
 
   //! Implementation of copy routine for string of other types
   template<typename TypeFrom>
   void fromUnicodeImpl (typename opencascade::std::enable_if<! opencascade::std::is_same<Type, TypeFrom>::value, const TypeFrom*>::type theStringUtf, 
                         const Standard_Integer theLength, NCollection_UtfIterator<TypeFrom>& theIterator)
   {
     Type* anOldBuffer = myString; // necessary in case of self-copying
 
     mySize = 0;
     const Standard_Integer aLengthMax = (theLength > 0) ? theLength : IntegerLast();
     for (; *theIterator != 0 && theIterator.Index() < aLengthMax; ++theIterator)
     {
       mySize += theIterator.template AdvanceBytesUtf<Type>();
     }
     myLength = theIterator.Index();
 
     myString = strAlloc (mySize);
 
     // copy string
     theIterator.Init (theStringUtf);
     Type* anIterWrite = myString;
     for (; *theIterator != 0 && theIterator.Index() < myLength; ++theIterator)
     {
       anIterWrite = theIterator.GetUtf (anIterWrite);
     }
 
     strFree (anOldBuffer);
   }
 
   //! Allocate NULL-terminated string buffer.
   static Type* strAlloc (const Standard_Size theSizeBytes)
   {
     Type* aPtr = (Type* )Standard::Allocate (theSizeBytes + sizeof(Type));
     if (aPtr != NULL)
     {
       // always NULL-terminate the string
       aPtr[theSizeBytes / sizeof(Type)] = Type(0);
     }
     return aPtr;
   }
 
   //! Release string buffer and nullify the pointer.
   static void strFree (Type*& thePtr)
   {
     Standard::Free (thePtr);
   }
 
   //! Provides bytes interface to avoid incorrect pointer arithmetics.
   static void strCopy (Standard_Byte*         theStrDst,
                        const Standard_Byte*   theStrSrc,
                        const Standard_Integer theSizeBytes)
   {
     std::memcpy (theStrDst, theStrSrc, (Standard_Size )theSizeBytes);
   }
 
   //! Compare two Unicode strings per-byte.
   static bool strAreEqual (const Type*            theString1,
                            const Standard_Integer theSizeBytes1,
                            const Type*            theString2,
                            const Standard_Integer theSizeBytes2)
   {
     return (theSizeBytes1 == theSizeBytes2)
         && (std::memcmp (theString1, theString2, (Standard_Size )theSizeBytes1) == 0);
   }
 
 private: //! @name private fields
 
   Type*            myString; //!< string buffer
   Standard_Integer mySize;   //!< buffer size in bytes, excluding NULL-termination symbol
   Standard_Integer myLength; //!< length of the string in Unicode symbols (cached value, excluding NULL-termination symbol)
 
 };
 
 typedef NCollection_UtfString<Standard_Utf8Char>  NCollection_Utf8String;
 typedef NCollection_UtfString<Standard_Utf16Char> NCollection_Utf16String;
 typedef NCollection_UtfString<Standard_Utf32Char> NCollection_Utf32String;
 typedef NCollection_UtfString<Standard_WideChar>  NCollection_UtfWideString;
 
 // template implementation (inline methods)
 #include "NCollection_UtfString.lxx"
 
 #endif // _NCollection_UtfString_H__

This page was automatically generated by the 2.3.7 LXR engine. The LXR team