IAIUnicodeString.h Go to the documentation of this file. /* * Name: IAIUnicodeString.h * $Revision: 1 $ * Author: * Date: * Purpose: Interface to the wrapper class for AIUnicodeStringSuite & the * primary interface for the AI core to * the ai::UnicodeString objects. * * ADOBE SYSTEMS INCORPORATED * Copyright 2004-2015 Adobe Systems Incorporated. * All rights reserved. * * NOTICE: Adobe permits you to use, modify, and distribute this file * in accordance with the terms of the Adobe license agreement * accompanying it. If you have received this file from a source other * than Adobe, then your use, modification, or distribution of it * requires the prior written permission of Adobe. * */ #ifndef _IAIUNICODESTRING_H_ #define _IAIUNICODESTRING_H_ #include "AITypes.h" #include "AICharacterEncoding.h" #include "IAIAutoBuffer.h" #include <string> #if defined(MAC_ENV) #import <CoreFoundation/CFString.h> #if defined _UTF16_BASIC_STRING_EXPORT_H_ #include _UTF16_BASIC_STRING_EXPORT_H_ #endif #endif // defined(MAC_ENV) class CAIUnicodeStringImpl; #define kUnicodeStringBadIndex 'US!I' #define kUnicodeStringLengthError 'US#L' #define kUnicodeStringMalformedError 'US!F' namespace ai { class const_PStr { public: explicit const_PStr(const unsigned char* pascalString) : fConstStr(pascalString) {}; virtual ~const_PStr() {} const_PStr(const const_PStr& p) : fConstStr(p.fConstStr) {}; const unsigned char* get() const { return fConstStr; } const unsigned char& operator[] (size_t i) const { return fConstStr[i]; } protected: const unsigned char* fConstStr; const_PStr& operator=(const const_PStr&); }; class PStr : public const_PStr { public: explicit PStr(unsigned char* pascalString) : const_PStr(pascalString) {}; PStr(const PStr& p) : const_PStr(p) {}; unsigned char* get() const { return const_cast<unsigned char*>(fConstStr); } unsigned char& operator[] (size_t i) const { return get()[i]; } //operator const const_PStr& () //{ return *this; } }; #if defined(WIN_ENV) class UnicodeString; class WCHARStr { public: typedef wchar_t WCHAR; typedef const WCHAR* LPCWSTR; typedef WCHAR* LPWSTR; public: WCHARStr () : fConstStr() {} WCHARStr (const ai::UnicodeString& string); #if defined(_NATIVE_WCHAR_T_DEFINED) // This ctor is redundant if wchar_t is not an intrinsic. It cannot be distinguished from the const ASUnicode* ctor. WCHARStr (LPCWSTR wcharString); #endif // defined(_NATIVE_WCHAR_T_DEFINED) WCHARStr (const ASUnicode* string); WCHARStr (const WCHARStr& p) : fConstStr(p.fConstStr) {} virtual ~WCHARStr() {} WCHARStr& operator= (const WCHARStr& rhs) { fConstStr = rhs.fConstStr; return *this; } LPCWSTR as_LPCWSTR () const { return fConstStr.c_str(); } const ASUnicode* as_ASUnicode () const; size_t length() const; /* Convenience operators */ #if defined(_NATIVE_WCHAR_T_DEFINED) // This operator is redundant if wchar_t is not an intrinsic. It cannot be distinguished from the const ASUnicode* operator. operator LPCWSTR () const { return as_LPCWSTR(); } #endif //defined(_NATIVE_WCHAR_T_DEFINED) operator const ASUnicode* () const { return as_ASUnicode(); } protected: std::basic_string<WCHAR> fConstStr; }; #endif /* WIN_ENV */ class UnicodeString { public: typedef ai::sizediff_t offset_type; typedef size_t size_type; static const size_type npos; static const ai::UnicodeString kEmptyString; typedef ASUInt32 UTF32TextChar; typedef ASUnicode UTF16Char; enum NormalizedForm { kForm_NFD = 0, kForm_NFC, kForm_NFKD, kForm_NFKC, kForm_DummyValue = 0xFFFFFFFF }; class Collator; public: //---------------------------------------------------------------------- //---------------------------------------------------------------------- explicit UnicodeString (void) AINOTHROW; explicit UnicodeString (const char* string, offset_type srcByteLen, AICharacterEncoding encoding = kAIPlatformCharacterEncoding); explicit UnicodeString (size_type count, UTF32TextChar ch); explicit UnicodeString (const char* string, AICharacterEncoding encoding = kAIPlatformCharacterEncoding); explicit UnicodeString (const std::string& string, AICharacterEncoding encoding = kAIPlatformCharacterEncoding); explicit UnicodeString (const ASUnicode* string); explicit UnicodeString (const ZRef zStringKey); explicit UnicodeString (const ASUnicode* string, size_type srcUTF16Count); explicit UnicodeString (const std::basic_string<ASUnicode>& string); UnicodeString (const UnicodeString& s); ~UnicodeString (void); //---------------------------------------------------------------------- //---------------------------------------------------------------------- static UnicodeString FromRoman (const char* string, size_type count); static UnicodeString FromRoman (const char* string); static UnicodeString FromRoman (const std::string& string); static UnicodeString FromRoman (const const_PStr& pascalString); static UnicodeString FromPlatform (const char* string, size_type count); static UnicodeString FromPlatform (const char* string); static UnicodeString FromPlatform (const std::string& string); static UnicodeString FromPlatform (const const_PStr& pascalString); static UnicodeString FromUTF8 (const char* string); static UnicodeString FromUTF8 (const std::string& string); static UnicodeString FromUTF8 (const const_PStr& pascalString); /* Basic operations (as in std::basic_string) */ UnicodeString& append (const UnicodeString& str); UnicodeString& append (const UnicodeString& str, size_type startOffset, size_type count); UnicodeString& append (size_type count, UTF32TextChar ch) { return append(UnicodeString(count, ch)); } UnicodeString& assign (const UnicodeString& str); UnicodeString& assign (const UnicodeString& str, size_type offset, size_type count) { return assign(str.substr(offset, count)); } UTF32TextChar at (size_type offset) const; void clear (); ai::int32 compare (const UnicodeString& str) const; ai::int32 compare (size_type pos, size_type num, const UnicodeString& str) const; ai::int32 compare (size_type pos, size_type num, const UnicodeString& str, size_type startOffset, size_type count) const; size_type length () const; bool empty () const; UnicodeString& erase (size_type pos=0, size_type count = npos); size_type find (UTF32TextChar ch, size_type startOffset = 0 ) const; size_type find (const UnicodeString& target, size_type startOffset = 0) const; size_type find (const UnicodeString& target, size_type startOffset, size_type count) const; size_type caseFind (UTF32TextChar ch, size_type startOffset = 0 ) const { return caseFind(ai::UnicodeString(1, ch), startOffset, 1); } size_type caseFind (const UnicodeString& target, size_type startOffset = 0) const { return caseFind(target, startOffset, target.length()); } size_type caseFind (const UnicodeString& target, size_type startOffset, size_type count) const; size_type rfind (UTF32TextChar ch, size_type startOffset = npos ) const; size_type rfind (const UnicodeString& target, size_type startOffset = npos) const; size_type rfind (const UnicodeString& target, size_type startOffset, size_type count) const; size_type find_first_of (const UnicodeString& target, size_type startOffset = 0) const { return find_first_of(target, startOffset, npos); } size_type find_first_of (const UnicodeString& target, size_type startOffset, size_type count) const; size_type find_last_of (const UnicodeString& target, size_type startOffset = npos) const { return find_last_of(target, startOffset, npos); } size_type find_last_of (const UnicodeString& target, size_type startOffset, size_type count) const; size_type find_first_not_of (const UnicodeString& target, size_type startOffset = 0) const { return find_first_not_of(target, startOffset, npos); } size_type find_first_not_of (const UnicodeString& target, size_type startOffset, size_type count) const; size_type find_last_not_of (const UnicodeString& target, size_type startOffset = npos) const { return find_last_not_of (target, startOffset, npos); } size_type find_last_not_of (const UnicodeString& target, size_type startOffset, size_type count) const; UnicodeString& replace (size_type pos, size_type num, const UnicodeString& str) { return replace(pos, num, str, 0, npos); } UnicodeString& replace (size_type pos, size_type num, const UnicodeString& str, size_type count) { return replace(pos, num, str, 0, count); } UnicodeString& replace (size_type pos, size_type num, const UnicodeString& str, size_type startOffset, size_type count); UnicodeString& insert (size_type insertOffset, const UnicodeString& str) { return insert(insertOffset, str, 0, npos); } UnicodeString& insert (size_type insertOffset, const UnicodeString& str, size_type offset, size_type count); UnicodeString& insert (size_type insertOffset, size_type count, UTF32TextChar ch) { return insert(insertOffset, UnicodeString(count, ch), 0, count); } void push_back(UTF32TextChar ch) { (void) append(1, ch); } void resize (size_type count, UTF32TextChar ch = UTF32TextChar()); ai::UnicodeString::size_type size (void) const { return length(); } UnicodeString substr (size_type offset = 0, size_type count = npos) const; void swap (UnicodeString& str); /* Operators */ UnicodeString& operator= (const UnicodeString& rhs); UnicodeString& operator+= (UTF32TextChar ch) { return append(1, ch); } UnicodeString& operator+= (const UnicodeString& rhs) { return append(rhs); } UTF32TextChar operator[] (size_type offset) const; bool operator== (const UnicodeString& rhs) const { return compare(rhs) == 0; } bool operator!= (const UnicodeString& rhs) const { return !(operator==(rhs)); } bool operator< (const UnicodeString& rhs) const { return compare(rhs) < 0; } /* non-std::basic_string based functionality */ UnicodeString& toLower(); UnicodeString& toUpper(); ai::int32 caseCompare (const UnicodeString& str) const { return caseCompare(0, npos, str, 0, npos); } ai::int32 caseCompare (size_type pos, size_type num, const UnicodeString& str) const { return caseCompare(pos, num, str, 0, npos); } ai::int32 caseCompare (size_type pos, size_type num, const UnicodeString& str, size_type startOffset, size_type count) const; ai::int32 canonicalCompare (const UnicodeString& str) const; ai::int32 canonicalCaseCompare (const UnicodeString& str) const; UnicodeString& normalize (NormalizedForm form); bool hasSurrogates () const; size_type utf_16 (const UTF16Char*& buffer) const; std::basic_string<ASUnicode> as_ASUnicode ( ) const; std::string as_UTF8 ( ) const; std::string as_Platform () const; std::string as_Roman () const; size_type getToBuffer ( char* buffer, size_type bufferMax, AICharacterEncoding encoding ) const; size_type getToBuffer ( const PStr& pascalString, size_type bufferMax, AICharacterEncoding encoding ) const; size_type as_ASUnicode (ASUnicode* buffer, size_type bufferMax ) const; size_type as_Platform ( const PStr& pascalString, size_type bufferMax ) const; size_type as_Platform ( char* buffer, size_type bufferMax ) const; size_type as_Roman ( char* buffer, size_type bufferMax ) const; size_type as_Roman ( const PStr& pascalString, size_type bufferMax ) const; std::string getInStdString (AICharacterEncoding encoding) const; size_type getAs (AICharacterEncoding encoding, ai::AutoBuffer<char>& b) const; #if defined(MAC_ENV) //---------------------------------------------------------------------- //---------------------------------------------------------------------- explicit UnicodeString (const CFStringRef& cfString); CFStringRef as_CFString (CFAllocatorRef alloc) const; #endif // defined(MAC_ENV) #if defined(WIN_ENV) //---------------------------------------------------------------------- //---------------------------------------------------------------------- explicit UnicodeString (const WCHARStr& string); WCHARStr as_WCHARStr () const; size_type as_WCHARStr (WCHARStr::LPWSTR buffer, size_type bufferMax ) const; #endif // defined(WIN_ENV) public: // internal use public interface void deleteImpl(); protected: explicit UnicodeString(class CAIUnicodeStringImpl* impl); private: CAIUnicodeStringImpl* fImpl; }; // Inline implementations - Yes, some of these could cause code bloat. // These could be moved to the IAIUnicodeString.inl file. // // UnicodeString inlines inline UnicodeString& UnicodeString::insert (size_type insertOffset, const UnicodeString& str, size_type offset, size_type count) { if ( insertOffset > length() || offset > str.length() ) throw ai::Error(kUnicodeStringBadIndex); UnicodeString result = substr(0, insertOffset); result.append(str, offset, count); result.append(substr(insertOffset)); *this = result; return *this; } inline UnicodeString& UnicodeString::replace (size_type pos, size_type num, const UnicodeString& str, size_type startOffset, size_type count) { if ( pos > length() || startOffset > str.length() ) throw ai::Error(kUnicodeStringBadIndex); erase(pos, num); insert(pos, str, startOffset, count); return *this; } inline std::string UnicodeString::as_UTF8 ( ) const { return getInStdString(kAIUTF8CharacterEncoding); } inline std::string UnicodeString::as_Platform () const { return getInStdString(kAIPlatformCharacterEncoding); } inline std::string UnicodeString::as_Roman () const { return getInStdString(kAIRomanCharacterEncoding); } inline UnicodeString::size_type UnicodeString::as_ASUnicode ( ASUnicode* buffer, size_type bufferMax ) const { const UTF16Char* bufPtr = 0; const size_type kThisUTF16Len = utf_16(bufPtr) + 1; const size_type kCopyMax = (bufferMax < kThisUTF16Len ? bufferMax : kThisUTF16Len) - 1; memcpy(buffer, bufPtr, kCopyMax*sizeof(UTF16Char)); buffer[kCopyMax] = 0; return kThisUTF16Len; } #if defined(WIN_ENV) inline UnicodeString::size_type UnicodeString::as_WCHARStr ( WCHARStr::LPWSTR buffer, size_type bufferMax ) const { AI_STATIC_CHECK(sizeof(WCHARStr::WCHAR) == sizeof(ai::UnicodeString::UTF16Char), WCHAR_size_does_not_match_unsigned_short_size); //-V503 return as_ASUnicode( reinterpret_cast<ASUnicode*>(buffer), bufferMax ); } #endif // defined(WIN_ENV) inline UnicodeString::size_type UnicodeString::as_Platform ( char* buffer, size_type bufferMax ) const { return getToBuffer( buffer, bufferMax, kAIPlatformCharacterEncoding); } inline UnicodeString::size_type UnicodeString::as_Roman ( char* buffer, size_type bufferMax ) const { return getToBuffer( buffer, bufferMax, kAIRomanCharacterEncoding); } inline UnicodeString::size_type UnicodeString::as_Platform ( const ai::PStr& pascalString, size_type bufferMax ) const { return getToBuffer( pascalString, bufferMax, kAIPlatformCharacterEncoding ); } inline UnicodeString::size_type UnicodeString::as_Roman ( const ai::PStr& pascalString, size_type bufferMax ) const { return getToBuffer( pascalString, bufferMax, kAIRomanCharacterEncoding ); } #if defined(WIN_ENV) // WCHARStr inlines inline WCHARStr::WCHARStr (const UnicodeString& string) : fConstStr() { AI_STATIC_CHECK(sizeof(WCHAR) == sizeof(ai::UnicodeString::UTF16Char), WCHAR_size_does_not_match_unsigned_short_size); //-V503 const std::basic_string<ASUnicode>& cInput = string.as_ASUnicode(); const size_t cLen = cInput.length(); if ( cLen > 0 ) fConstStr = std::basic_string<WCHAR>(reinterpret_cast<LPCWSTR>(cInput.data()), cLen); }; #if defined(_NATIVE_WCHAR_T_DEFINED) // This ctor is redundant if wchar_t is not an intrinsic. This is the same as the const ASUnicode* ctor. inline WCHARStr::WCHARStr (WCHARStr::LPCWSTR wcharString) : fConstStr( wcharString ) { } #endif // defined(_NATIVE_WCHAR_T_DEFINED) inline WCHARStr::WCHARStr (const ASUnicode* string) { if ( string && *string ) { AI_STATIC_CHECK(sizeof(WCHARStr::WCHAR) == sizeof(ai::UnicodeString::UTF16Char), WCHAR_size_does_not_match_unsigned_short_size); //-V503 fConstStr.assign(reinterpret_cast<LPCWSTR>(string)); } } inline const ASUnicode* WCHARStr::as_ASUnicode () const { AI_STATIC_CHECK(sizeof(WCHARStr::WCHAR) == sizeof(ai::UnicodeString::UTF16Char), WCHAR_size_does_not_match_unsigned_short_size); //-V503 return reinterpret_cast<const ASUnicode*>(this->as_LPCWSTR()); } inline size_t WCHARStr::length() const { return fConstStr.length(); } #endif // defined(WIN_ENV) } // end of namespace ai #endif // _IAIUNICODESTRING_H_

Copyright © 2016 Adobe Systems Incorporated. All rights reserved. Terms of Use Online Privacy Policy Adobe and accessibility Avoid software piracy Permissions and Trademarks