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> #include <iterator> #include <stdexcept> #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) {} #if defined(AI_HAS_RVALUE_REFERENCES) && defined(AI_HAS_DEFAULTED_FUNCTIONS) WCHARStr (WCHARStr&&) = default; #endif virtual ~WCHARStr() {} WCHARStr& operator= (const WCHARStr& rhs) { fConstStr = rhs.fConstStr; return *this; } #if defined(AI_HAS_RVALUE_REFERENCES) && defined(AI_HAS_DEFAULTED_FUNCTIONS) WCHARStr& operator= (WCHARStr&&) = default; #endif 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; typedef ASUInt32 UTF32TextChar; typedef ASUnicode UTF16Char; typedef UTF32TextChar value_type; static const size_type npos; enum NormalizedForm { kForm_NFD = 0, kForm_NFC, kForm_NFKD, kForm_NFKC, kForm_DummyValue = 0xFFFFFFFF }; class Collator; // ai::UnicodeString doesn't support non-const iterators because // its operator[] or at() doesn't return a reference to value_type // and for the same reason const_iterator doesn't overload operator->() class const_iterator; friend class const_iterator; public: class const_iterator : public std::iterator<std::random_access_iterator_tag, UnicodeString::value_type> { public: typedef const_iterator self_type; typedef UnicodeString::size_type size_type; typedef const UnicodeString* container_type; // default construct NULL iterator // can't be dereferenced, incremented or decremented const_iterator() : fIndex(0), fStringContainer(nullptr) { } // construct iterator corresponding to a given index in the container const_iterator(size_type index, container_type container) : fIndex(index), fStringContainer(container) { } const_iterator(const self_type& rhs) = default; // copy constructor self_type& operator=(const self_type& rhs) = default; // copy assignment value_type operator*() const { if (!fStringContainer || fIndex >= fStringContainer->size()) { throw std::out_of_range{"string iterator not dereferencable"}; } return (*fStringContainer)[fIndex]; } self_type& operator++() // preincrement { ++fIndex; return (*this); } self_type operator++(int) // postincrement { auto temp = *this; ++(*this); return temp; } self_type& operator--() // predecrement { --fIndex; return (*this); } self_type operator--(int) // postdecrement { auto temp = *this; --(*this); return temp; } self_type& operator+=(difference_type offset) // increment by integer { fIndex += offset; return (*this); } self_type operator+(difference_type offset) const // return this + integer { self_type temp = *this; return (temp += offset); } self_type& operator-=(difference_type offset) // decrement by integer { fIndex -= offset; return (*this); } self_type operator-(difference_type offset) const // return this - integer { self_type temp = *this; return (temp -= offset); } difference_type operator-(const self_type& rhs) const // return difference of iterators { return (fIndex - rhs.fIndex); } bool operator==(const self_type& rhs) const // test for iterator equality { return (fIndex == rhs.fIndex); } bool operator!=(const self_type& rhs) const // test for iterator inequality { return !(*this == rhs); } bool operator<(const self_type& rhs) const // test if this < rhs { return (fIndex < rhs.fIndex); } bool operator>(const self_type& rhs) const // test if this > rhs { return (rhs < *this); } bool operator<=(const self_type& rhs) const // test if this <= rhs { return (!(rhs < *this)); } bool operator>=(const self_type& rhs) const // test if this >= rhs { return (!(*this < rhs)); } private: bool compatible(const self_type& rhs) const { return (fStringContainer->fImpl == rhs.fStringContainer->fImpl); } private: size_type fIndex = 0; container_type fStringContainer; }; //---------------------------------------------------------------------- //---------------------------------------------------------------------- explicit UnicodeString () 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); #ifdef AI_HAS_RVALUE_REFERENCES UnicodeString(UnicodeString&& other) AINOEXCEPT; #endif // AI_HAS_RVALUE_REFERENCES ~UnicodeString (); //---------------------------------------------------------------------- //---------------------------------------------------------------------- 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); const_iterator erase (const_iterator position) { size_type index = position - begin(); erase(index, 1); return (begin() + index); } const_iterator erase (const_iterator first, const_iterator last) { size_type index = first - begin(); erase(index, last - first); return (begin() + index); } 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 capacity () const; void reserve (size_type count); ai::UnicodeString::size_type size () const { return length(); } UnicodeString substr (size_type offset = 0, size_type count = npos) const; void swap (UnicodeString& str) AINOEXCEPT; /* Operators */ UnicodeString& operator= (const UnicodeString& rhs); #ifdef AI_HAS_RVALUE_REFERENCES UnicodeString& operator= (UnicodeString&& rhs) AINOEXCEPT; #endif // AI_HAS_RVALUE_REFERENCES 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; } const_iterator begin() const { return const_iterator(0, this); } const_iterator end() const { return const_iterator(this->size(), this); } /* 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: mutable CAIUnicodeStringImpl* fImpl; }; inline UnicodeString operator+(UnicodeString lhs, const UnicodeString& rhs) { return lhs.append(rhs); } // Inline implementations - Yes, some of these could cause code bloat. // These could be moved to the IAIUnicodeString.inl file. // // UnicodeString inlines inline void UnicodeString::swap(UnicodeString& str) AINOEXCEPT { std::swap(fImpl, str.fImpl); } #ifdef AI_HAS_RVALUE_REFERENCES // Move Constructor inline UnicodeString::UnicodeString(UnicodeString&& other) AINOEXCEPT : fImpl{other.fImpl} { other.fImpl = nullptr; } // Move Assignment operator inline UnicodeString& UnicodeString::operator=(UnicodeString&& rhs) AINOEXCEPT { swap(rhs); return *this; } #endif // AI_HAS_RVALUE_REFERENCES 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 © 2014 Adobe Systems Incorporated. All rights reserved. Terms of Use Online Privacy Policy Adobe and accessibility Avoid software piracy Permissions and Trademarks