DataWrapper.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.
// 
// 
// A DataWrapper is a safe way of passing around information that is owned
// by a persistent object. It maintains a reference to the persistent object
// and a pointer to the data that is wanted. Thus, when the datawrapper leaves
// scope, the persistent object is released, which allows the datawrapper's data
// to be deleted.
// 
//========================================================================================

#ifndef __DATAWRAPPER__
#define __DATAWRAPPER__

#include "VOSObject.h"
#include "WideString.h"


template <class DataT>
class DataWrapper
{
 public:
 DataWrapper() :fBlock(nil), fData(nil)
 {}
 DataWrapper(VOS_Object* block, const DataT* list) :fBlock(block), fData((DataT *)list)
 { if (fBlock) fBlock->AddRef(); }

 DataWrapper(const DataWrapper<DataT>& copy) :fBlock(copy.fBlock), fData(copy.fData)
 { if (fBlock) fBlock->AddRef(); }

 DataWrapper<DataT>& operator=(const DataWrapper<DataT>& copy);

 ~DataWrapper()
 { if (fBlock) fBlock->Release(); }

 operator const DataT* () const
 { return fData; }

 const DataT* get() const
 { return fData; }

 private:
 VOS_Object *fBlock;
 DataT *fData;
};



template <> class DataWrapper<textchar>
{
 public:
 DataWrapper() :fBlock(nil), fData(nil), fCharOffset(0)
 {}
 DataWrapper(VOS_Object* block, const WideString* str, int32 charOffset)
 :fBlock(block), fData(str), fCharOffset(charOffset)
 { if (fBlock) fBlock->AddRef(); }

 DataWrapper(const DataWrapper<textchar>& copy)
 :fBlock(copy.fBlock), fData(copy.fData), fCharOffset(copy.fCharOffset)
 { if (fBlock) fBlock->AddRef(); }

 DataWrapper<textchar>& operator=(const DataWrapper<textchar>& copy);

 ~DataWrapper()
 { if (fBlock) fBlock->Release(); }

 operator const textchar*()
 { return fData ? fData->GrabUTF16Buffer(nil) + fData->CodePointIndexToUTF16Index(fCharOffset) : nil; }

 WideString::const_iterator GetIteratorAt(int32 charOffset) const;

 void ClearOffset()
 { fCharOffset = 0; }

 int32 CharOffsetToUTF16Offset(int32 charOffset) const;

 bool16 HasSurrogates() const
 { return fData->HasMultiWordUnicode(); }

 const WideString* GetData() const
 { return fData; }

 private:
 DataWrapper<textchar>& operator+=(int32 /*charOffset*/); // not provided -- make the compiler catch this bad call...
 DataWrapper<textchar>& operator-=(int32 /*charOffset*/); // not provided -- make the compiler catch this bad call...

 private:
 VOS_Object *fBlock;
 const WideString *fData;
 int32 fCharOffset;
};



#endif
 // __DATAWRAPPER__