StringStorage.h

//========================================================================================
// 
// $File$
// 
// Owner: EricM
// 
// $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.
// 
//========================================================================================

#ifndef __STRINGSTORAGE__
#define __STRINGSTORAGE__

#include "BaseType.h"
#include "IDThreading.h"

const int32 kStringStorageChunk = 32;

// Given a requested length (newLength) & currentLength return a padded new size for the buffer.
// Performance optimization.
// Increase the size of the string by 50% Performance measurements have shown that in the case
// of large strings we pay a large penalty in the extra calls to memcpys if the size is increased
// by some small chunk size like 16 or 32. For very large strings (as in XML SaveBackwards) this change
// resulted in a 50% speed up. [jshankar Aug-5-2003]
// If currentLength is zero then default value of kStringChunk is used.
inline int32 CalcStringSizeW(int32 newLength, int32 currentLength)
{
 ASSERT(newLength >= 0 && currentLength >= 0);
 ASSERT(newLength < 128 * 1024 * 1024);
 ASSERT(currentLength < 128 * 1024 * 1024);

 int32 myStringChunk = currentLength / 2;

 // Ensure minimum string chunk size
 if (myStringChunk < kStringStorageChunk)
 myStringChunk = kStringStorageChunk;

 ASSERT(myStringChunk > 0);
 const int32 calcLength = myStringChunk * ((newLength + myStringChunk -1 ) / myStringChunk);
 ASSERT(calcLength >= newLength);
 return calcLength;
}



int32 CheckTotalUnicodeSavvyStringReferences();


class StringStorage
{
public:
 // traits
 typedef int32 size_type;

 enum {kDefaultLength = 16};

 static StringStorage *CreateStringStorage(int32 initialLength = kDefaultLength, StringStorage *sourceStr = nil);

 operator const UTF16TextChar *(void) const;
 UTF16TextChar operator[](int pos) const;

 StringStorage * MakeSize(size_type requestedSize);

 size_type capacity() const;

 UTF16TextChar * GetBuffer();
 const UTF16TextChar *ConstBuffer() const;

 StringStorage * Copy();
 void Dispose();

 bool IsUnique() const;


#ifdef DEBUG

 void Validate();

 static int32 TotalAllocatedMemory();

 static int32 TotalReferences();
#endif


protected:
 StringStorage(int32 initialLength, size_type adjustedLength) ;

 StringStorage(const StringStorage &srcStorage, size_type initialLength, size_type adjustedLength);

 int32 fMemorySize; // number of textchars allocated for the buffer
 int32 fRequestedSize; // number of textchars required for the buffer
 size_type fReferenceCount; // number of strings that use this buffer
 UTF16TextChar fFirstCharOfBuffer[1]; // the rest continues and is allocated together in this block

private:
#ifdef DEBUG
 // In a multi-threaded environment these stats may not be updated accurately.
 // Atomic add and subtracts of these stats are required in order to have accurate values. 
 // This would put a great overhead on the performance. Hence, we are not using atomic add and
 // subtract expecting that these stats need not be accurate.
 static int32 ts_TotalReferences;
 static int32 ts_TotalAllocatedMemory;
#endif
};


inline StringStorage::operator const UTF16TextChar *(void) const
{
 return ConstBuffer();
}

inline UTF16TextChar *StringStorage::GetBuffer()
{
 ASSERT(fReferenceCount == 1);
 return fFirstCharOfBuffer;
}

inline const UTF16TextChar *StringStorage::ConstBuffer() const
{
 return fFirstCharOfBuffer;
}


inline UTF16TextChar StringStorage::operator [] (int pos) const
{
 ASSERT(fRequestedSize > 0);
 return ConstBuffer()[pos];
}


inline StringStorage * StringStorage::Copy()
{
 IDThreading::AtomicIncrement(fReferenceCount);
#ifdef DEBUG
 ++ts_TotalReferences;
#endif
 return this;
}


inline StringStorage::size_type StringStorage::capacity() const
{
 return fMemorySize - 1;
}

inline bool StringStorage::IsUnique() const
{
 return (fReferenceCount == 1);
}

#ifdef DEBUG
inline int32 StringStorage::TotalReferences()
{
 return ts_TotalReferences;
}

inline int32 StringStorage::TotalAllocatedMemory()
{
 return ts_TotalAllocatedMemory;
}
#endif


#endif // __STRINGSTORAGE__