PersistBaseTypes.h

//========================================================================================
// 
// $File$
// 
// Owner: Abhishek Gulati
// 
// $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 __PersistBasic__
#define __PersistBasic__

#include "IPMStream.h"
#include "k2VectorStreaming.h"
#include "BaseType.h"

namespace Persist
{
 template<>
 inline void Read<uint8>(IPMStream* stream, uint8& n)
 {
 ASSERT (stream && stream->IsReading());
 K2Read (stream, n);
 }

 template<>
 inline void Write<uint8>(IPMStream* stream, const uint8& n)
 {
 ASSERT (stream && stream->IsWriting());
 K2Write (stream, n);
 }

 template<>
 inline void Read<uint16>(IPMStream* stream, uint16& n)
 {
 ASSERT (stream && stream->IsReading());
 K2Read (stream, n);
 }

 template<>
 inline void Write<uint16>(IPMStream* stream, const uint16& n)
 {
 ASSERT (stream && stream->IsWriting());
 K2Write (stream, n);
 }

 template<>
 inline void Read<uint32>(IPMStream* stream, uint32& n)
 {
 ASSERT (stream && stream->IsReading());
 K2Read (stream, n);
 }

 template<>
 inline void Write<uint32>(IPMStream* stream, const uint32& n)
 {
 ASSERT (stream && stream->IsWriting());
 K2Write (stream, n);
 }

 template<>
 inline void Read<uint64>(IPMStream* stream, uint64& i)
 {
 ASSERT (stream && stream->IsReading());
 int64 temp(0);
 stream->XferInt64(temp);
 i = temp;
 }

 template<>
 inline void Write<uint64>(IPMStream* stream, const uint64& i)
 {
 ASSERT (stream && stream->IsWriting());
 // Copy to a non-const int64 to match XferID signature. 
 int64 iNonConst = i;
 stream->XferInt64(iNonConst);
 }

 template<>
 inline void Read<int16>(IPMStream* stream, int16& i)
 {
 ASSERT (stream && stream->IsReading());
 K2Read (stream, i);
 }

 template<>
 inline void Write<int16>(IPMStream* stream, const int16& i)
 {
 ASSERT (stream && stream->IsWriting());
 K2Write (stream, i);
 }

 template<>
 inline void Read<int32>(IPMStream* stream, int32& i)
 {
 ASSERT (stream && stream->IsReading());
 K2Read (stream, i);
 }

 template<>
 inline void Write<int32>(IPMStream* stream, const int32& i)
 {
 ASSERT (stream && stream->IsWriting());
 K2Write (stream, i);
 }

 template<>
 inline void Read<int64>(IPMStream* stream, int64& i)
 {
 ASSERT (stream && stream->IsReading());
 stream->XferInt64(i);
 }

 template<>
 inline void Write<int64>(IPMStream* stream, const int64& i)
 {
 ASSERT (stream && stream->IsWriting());
 // Copy to a non-const int64 to match XferID signature. 
 int64 iNonConst = i;
 stream->XferInt64(iNonConst);
 }

 template<>
 inline void Read<PMReal>(IPMStream* stream, PMReal& n)
 {
 ASSERT (stream && stream->IsReading());
 K2Read (stream, n);
 }

 template<>
 inline void Write<PMReal>(IPMStream* stream, const PMReal& n)
 {
 ASSERT (stream && stream->IsWriting());
 K2Write (stream, n);
 }

 template<>
 inline void Read<PMPoint>(IPMStream* stream, PMPoint& n)
 {
 ASSERT (stream && stream->IsReading());
 K2Read (stream, n);
 }

 template<>
 inline void Write<PMPoint>(IPMStream* stream, const PMPoint& n)
 {
 ASSERT (stream && stream->IsWriting());
 K2Write (stream, n);
 }

 template<>
 inline void Read(IPMStream* stream, PMRect& n)
 {
 ASSERT (stream && stream->IsReading());
 K2Read (stream, n);
 }

 template<>
 inline void Write(IPMStream* stream, const PMRect& n)
 {
 ASSERT (stream && stream->IsWriting());
 K2Write (stream, n);
 }


 template <typename T>
 struct Serializer < IDType<T> >
 {
 inline static void Read (IPMStream* stream, IDType<T>& id)
 {
 stream->XferID(id);
 }

 inline static void Write (IPMStream* stream, const IDType<T>& id)
 {
 // Cast constness away to to match XferID signature. This should be safe since 
 // XferID does not modify the object when the stream is being written to.
 stream->XferID(const_cast<IDType<T>&>(id));
 }
 };


 template<>
 inline void Read<UTF32TextChar>(IPMStream* stream, UTF32TextChar& u)
 {
 ASSERT (stream && stream->IsReading());
 u.ReadWriteUTF16(stream);
 }

 template<>
 inline void Write<UTF32TextChar>(IPMStream* stream, const UTF32TextChar& u)
 {
 ASSERT (stream && stream->IsWriting());
 // Cast constness away to to match XferID signature. This should be safe since 
 // ReadWriteUTF16 does not modify the object when the stream is being written to.
 UTF32TextChar& uNonConst = const_cast<UTF32TextChar&> (u);
 uNonConst.ReadWriteUTF16(stream);
 }
}

#endif