UnicodeSavvyString.h

//========================================================================================
// 
// $File$
// 
// Owner:
// 
// $Author$
// 
// $DateTime$
// 
// $Revision$
// 
// $Change$
// 
// Copyright 1997-2010 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.
// 
// 
// A 16-bit character string.
// 
//========================================================================================

#ifndef __UNICODESAVVYSTRING
#define __UNICODESAVVYSTRING

#include "PlatformChar.h"
#include <cstddef>
#include <iterator> // for iterator_traits
#include <boost/static_assert.hpp>
#include <adobe/move.hpp>

 int32 CharOffsetToUTF16Offset(const UTF16TextChar *buffer, int32 length, int32 charOffset);
 int UTF16TextCharCompare(const UTF16TextChar *utf16str1, const UTF16TextChar *utf16str2);
 size_t UTF16TextCharLength(const UTF16TextChar *utf16str);

//class StringStorage;
// We can't debug the StringStorage if we use a forward declare (bug in MSDev Studio 2003)
// This bug is fixed in MS Dev Studio 2005, so we should go back to a forward declare than.
#include "StringStorage.h"

class UnicodeSavvyString
{
 // Copy constructor and assignment disabled
 UnicodeSavvyString(const UnicodeSavvyString& s);
 UnicodeSavvyString& operator=(const UnicodeSavvyString& s);

public:
 // traits
 typedef int32 size_type;
 typedef std::ptrdiff_t difference_type;
 typedef UTF16TextChar code_value;
 typedef UTF32TextChar code_point;
 typedef code_value* code_value_iterator;
 typedef code_value const* const_code_value_iterator;
 typedef const UnicodeSavvyString& const_reference;
 typedef UTF16TextChar value_type;

 bool16 HasMultiWordUnicode() const
 {
 return fNumChars != fUTF16BufferLength;
 }

 size_type CharCount() const
 {
 return fNumChars;
 }

 size_type NumUTF16TextChars() const
 {
 return fUTF16BufferLength;
 }

 size_type capacity(void) const
 {
 return (UnicodeBufferIsValid()) ? fStorage->capacity() : kMaxSmallString;
 }

 void reserve(size_type newCapacity);

 void resize(size_type newSize, code_value fill = code_value());

 friend inline void swap(UnicodeSavvyString& lhs, UnicodeSavvyString& rhs) noexcept
 {
 std::swap_ranges(lhs.fSmallStorage, lhs.fSmallStorage + kMaxSmallString + 1, rhs.fSmallStorage);
 std::swap(lhs.fStorage, rhs.fStorage);
 std::swap(lhs.fUTF16BufferLength, rhs.fUTF16BufferLength);
 std::swap(lhs.fNumChars, rhs.fNumChars);
 }

 void clear();

 const UTF16TextChar* GrabUTF16Buffer(int32* numUTF16s) const;

 int32 CodePointIndexToUTF16Index(int32 index) const;

 void Truncate(CharCounter count);

 void Remove(int32 position, CharCounter count);


 UTF32TextChar GetUTF32TextChar(int32 pos) const;


 const_code_value_iterator begin() const
 {
 return ConstBuffer();
 }

 const_code_value_iterator end() const
 {
 return ConstBuffer() + fUTF16BufferLength;
 }


protected:
 UnicodeSavvyString() : fStorage(nil), fUTF16BufferLength(0), fNumChars(0)
 {
 fSmallStorage[0] = UTF16TextChar();
 }

 UnicodeSavvyString(adobe::move_from<UnicodeSavvyString> other)
 : fStorage(nil)
 {
 move_from(other.source);
 }
 
 UnicodeSavvyString(UnicodeSavvyString &&other) noexcept
 : fStorage(nil)
 {
 move_from(other);
 }

 void move_from(UnicodeSavvyString& other) noexcept
 {
 std::swap(fStorage, other.fStorage);
 fUTF16BufferLength = other.fUTF16BufferLength;
 fNumChars = other.fNumChars;

 if (!fStorage && fUTF16BufferLength)
 std::copy(other.fSmallStorage, other.fSmallStorage + kMaxSmallString + 1, fSmallStorage);
 else
 fSmallStorage[0] = code_value();

 other.fUTF16BufferLength = other.fNumChars = 0;
 }

 ~UnicodeSavvyString();

 template <class IteratorType>
 UnicodeSavvyString(IteratorType b, IteratorType e, size_type nCodePoints = 0)
 : fStorage(nil), fUTF16BufferLength(0), fNumChars(0)
 {
 assign(b, e, nCodePoints);
 }

 int32 CountChars() const;
 int32 CountCharsUtil(const UTF16TextChar* buffer, int32 bufferLength) const;

 // Buffer manipulation
 void InsertGap(uint32 wordWiseIndex, size_type numberOfSpaces);
 void RemoveGap(uint32 wordWiseIndex, size_type numberOfSpaces);

 void InsertUTF32TextChar(UTF32TextChar c, int32 pos = 0);
 void InsertUTF16String(const UTF16TextChar* buf, int32 len, int32 position = 0);

 void AppendUTF32TextChar(UTF32TextChar c32);

 void CopyFrom(const UnicodeSavvyString& other);

 bool16 operator==(const UnicodeSavvyString& s) const;

#ifdef DEBUG
 void CheckPairedSurrogates(const UTF16TextChar* buffer, int32 utf16Count) const;

 void InvariantCheck() const;

 struct InvariantChecker
 {
 InvariantChecker(UnicodeSavvyString const& s) : fString(s)
 {
 fString.InvariantCheck();
 }

 ~InvariantChecker()
 {
 fString.InvariantCheck();
 }
 private:
 UnicodeSavvyString const& fString;
 };
#endif

 template <class IteratorType>
 UnicodeSavvyString& assign(IteratorType b, IteratorType e, size_type nCodePoints = 0);

 UnicodeSavvyString& replace(size_type pos, size_type n1,
 code_value const* s, size_type n2);

 UnicodeSavvyString& append(code_value const* s, size_type nCodeValues, size_type nCodePoints = 0);

protected:
 UTF32TextChar surro_GetUTF32TextChar(int32 pos) const;
 const UTF16TextChar* ConstBuffer() const
 {
 return UnicodeBufferIsValid() ? fStorage->ConstBuffer() : fSmallStorage;
 }

 // Utility functions that are called under a "safe" circumstance.
 // Should not be used directly
 void insert_safe(code_value_iterator i, const_code_value_iterator sb, const_code_value_iterator se);
 void erase_safe(code_value_iterator b, code_value_iterator e);
 void replace_safe(code_value_iterator b, code_value_iterator e,
 const_code_value_iterator sb, const_code_value_iterator se);


 template <class InputIterator>
 void assign_impl(InputIterator b, InputIterator e, size_type nCodePoints, std::input_iterator_tag);

 template <class FwdIterator>
 void assign_impl(FwdIterator b, FwdIterator e, size_type nCodePoints, std::forward_iterator_tag);

 //fStorage may have two states:
 // 1) It is allocated and terminated with a trailing zero
 // 2) Is is nil, and the storage has already been released
 // UnicodeBufferIsValid() distinguishes these states
 bool16 UnicodeBufferIsValid() const
 {
 return (fStorage ? true : false);
 }

 UTF16TextChar* GetBufferForWriting(size_type size);

protected:
 StringStorage* fStorage; // big storage

 enum {kMaxSmallString = 23}; // Threshold for the small buffer
 UTF16TextChar fSmallStorage[kMaxSmallString + 1]; // Small string optimization

 size_type fUTF16BufferLength; // The number of UTF16s in here
 size_type fNumChars; // The number of Unicode codepoints (2 surrogates == 1 char == 1 codepoint) in here
};


// Inline implementations below:

// Assign with iterators
template <class IteratorType>
inline UnicodeSavvyString& UnicodeSavvyString::assign(IteratorType b, IteratorType e, size_type nCodePoints)
{
 // The value from the iterator should be 16 bit
 typedef typename std::iterator_traits<IteratorType>::value_type iterator_value_type;
 BOOST_STATIC_ASSERT(sizeof(iterator_value_type)*CHAR_BIT == 16);
 typedef typename std::iterator_traits<IteratorType>::iterator_category iterator_category;

#ifdef DEBUG
 InvariantChecker checkThis(*this);
#endif

 // Dispatch to the optimized version
 assign_impl(b, e, nCodePoints, iterator_category());
 return *this;
}

// Input iterators assign implementation
template <class InputIterator>
inline void UnicodeSavvyString::assign_impl(InputIterator b, InputIterator e, size_type nCodePoints, std::input_iterator_tag)
{
 UnicodeSavvyString temp;

 // Try to optimize allocations in case the client told us the number of code points.
 if (nCodePoints)
 {
 temp.reserve(nCodePoints);
 }

 std::copy(b, e, std::back_inserter(temp));
 swap(*this, temp);
}

template <class FwdIterator>
inline void UnicodeSavvyString::assign_impl(FwdIterator b, FwdIterator e, size_type nCodePoints, std::forward_iterator_tag)
{
 const difference_type nCodeValues = std::distance(b, e);
 ASSERT(nCodeValues >= 0);

 // Make room for the chars
 code_value* buffer = GetBufferForWriting(nCodeValues);

 // Copy them into the buffer
 std::copy(b, e, buffer);

 // Ensure terminating null
 buffer[nCodeValues] = code_value();

 fUTF16BufferLength = nCodeValues;

 // Calculate how many code points we will have at the end
 if (nCodePoints == 0 && nCodeValues)
 {
 fNumChars = CountCharsUtil(buffer, nCodeValues);
 }
 else
 {
 ASSERT((size_type)CountCharsUtil(buffer, nCodeValues) == nCodePoints);
 fNumChars = nCodePoints;
 }
}



inline int32 UnicodeSavvyString::CodePointIndexToUTF16Index(int32 index) const
{
 return HasMultiWordUnicode() ? CharOffsetToUTF16Offset(ConstBuffer(), fUTF16BufferLength, index) : index;
}

inline const UTF16TextChar * UnicodeSavvyString::GrabUTF16Buffer(int32* numUTF16s) const
{
 if (numUTF16s)
 {
 *numUTF16s = fUTF16BufferLength;
 }
 return ConstBuffer();
}

inline UTF32TextChar UnicodeSavvyString::GetUTF32TextChar(int32 pos) const
{
 return HasMultiWordUnicode() ? surro_GetUTF32TextChar(pos) : UTF32TextChar(ConstBuffer()[pos]);
}


inline int32 UnicodeSavvyString::CountChars() const
{
 return CountCharsUtil(ConstBuffer(), fUTF16BufferLength);
}



inline UTF16TextChar * UnicodeSavvyString::GetBufferForWriting(UnicodeSavvyString::size_type len)
{
 reserve(len);
 return fStorage ? fStorage->GetBuffer() : &fSmallStorage[0];
}









#endif