IPMStream.h

//========================================================================================
// 
// $File$
// 
// Owner: Robin Briggs
// 
// $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.
// 
// 
// Purpose:
// This is the interface used for serializing objects.
// 
// Streams are normally created for you by methods in the StreamUtil class.
// 
//========================================================================================

#include "IPMUnknown.h"

#ifndef __IPMSTREAM__
#define __IPMSTREAM__


typedef enum
{
 kSeekFromStart = 0x01,
 kSeekFromCurrent = 0x02,
 kSeekFromEnd = 0x04
} SeekFromWhere;

/* Modes used for opening files */
typedef enum
{
 kOpenIn = 0x01,
 kOpenOut = 0x02,
 kOpenApp = 0x04,
 kOpenTrunc = 0x08
} OpenMode;

typedef enum
{
 kStreamStateGood = 0,
 kStreamStateEOF,
 kStreamStateFailure,
 kStreamStateClosed
} StreamState;

#ifdef DEBUG
#include "IDBStreamData.h"
#include "DocumentID.h"
#include "WorkspaceID.h"

#define ASSERT_IF_WRITING_TO_DOCUMENT(db_Stream) if(db_Stream->IsWriting()) {\
 InterfacePtr<IDBStreamData> db_StreamData(db_Stream,IID_IDBSTREAMDATA);\
 if (db_StreamData != nil)\
 {\
 IDataBase *stream_DB = db_StreamData->GetDataBase();\
 UID db_rootUID = stream_DB->GetRootUID();\
 ASSERT_MSG(stream_DB->GetClass(db_rootUID) != kDocBoss,"This shouldn't be written to a pub database!");\
 }}

#define ASSERT_IF_WRITING_TO_DEFAULTS(db_Stream) if(db_Stream->IsWriting()) {\
 InterfacePtr<IDBStreamData> db_StreamData(db_Stream,IID_IDBSTREAMDATA);\
 if (db_StreamData != nil)\
 {\
 IDataBase *stream_DB = db_StreamData->GetDataBase();\
 UID db_rootUID = stream_DB->GetRootUID();\
 ASSERT_MSG(stream_DB->GetClass(db_rootUID) != kWorkspaceBoss,"This shouldn't be written to a defaults database!");\
 }}

#else
#define ASSERT_IF_WRITING_TO_DOCUMENT(stream)
#define ASSERT_IF_WRITING_TO_DEFAULTS(stream)
#endif

// Use IPMStream::XferEnum instead of the XFER_ENUM and XFER_ENUM16 macros
#define XFER_ENUM(stream, enumVal) { stream->XferInt32((int32&)enumVal); }
#define XFER_ENUM16(stream, enumVal) { int16 _dummy = (int16) enumVal; (int32&) enumVal = (int32) stream->XferInt16(_dummy); }

class IPMStream : public IPMUnknown
{
 public:
 typedef enum _StreamType {
 kUnknown,
 kReader,
 kWriter
 } StreamType;

 template<typename T> inline void XferEnum(T& e)
 {
 int32 tmp(0);
 if (IsReading()) {
 XferInt32(tmp);
 e = static_cast<T>(tmp);
 }
 else {
 tmp = static_cast<int32>(e);
 XferInt32(tmp);
 }
 }
 
 virtual ~IPMStream() {}
 virtual uchar XferByte(uchar& chr) = 0;
 virtual int32 XferByte(uchar *buf, int32 num) = 0;

 virtual bool16 XferBool(bool16& chr) = 0;
 virtual int32 XferBool(bool16 *buf, int32 num) = 0;

 virtual int16 XferInt16(int16& i) = 0;
 virtual int32 XferInt16(int16 *buf, int32 num) = 0;

 virtual int32 XferInt32(int32& i) = 0;
 virtual int32 XferInt32(int32 *buf, int32 num) = 0;

 virtual int64 XferInt64(int64& i) = 0;

 virtual uintptr_t XferPointer(uintptr_t& i) = 0;

 template<class T>
 inline IDType<T> XferID(IDType<T>& id)
 {
 XferInt32((int32&)id.Get());
 return id;
 }

 template<class T>
 inline int32 XferID(IDType<T>* buf, int32 count)
 {
 for (int32 i = 0; i < count; ++i)
 XferID(buf[i]);
 return count;
 }

 virtual ClassID XferID(ClassID& i) = 0;
 virtual int32 XferID(ClassID *buf, int32 num) = 0;

 virtual ImplementationID XferID(ImplementationID& i) = 0;
 virtual int32 XferID(ImplementationID *buf, int32 num) = 0;

 virtual WidgetID XferID(WidgetID& i) = 0;
 virtual int32 XferID(WidgetID *buf, int32 num) = 0;

 virtual PluginID XferID(PluginID& i) = 0;
 virtual int32 XferID(PluginID *buf, int32 num) = 0;

 virtual PMIID XferID(PMIID& i) = 0;
 virtual int32 XferID(PMIID *buf, int32 num) = 0;

 virtual ActionID XferID(ActionID& i) = 0;
 virtual int32 XferID(ActionID *buf, int32 num) = 0;

 virtual ScriptElementID XferID(ScriptElementID& i) = 0;
 virtual int32 XferID(ScriptElementID *buf, int32 num) = 0;

 virtual ScriptID XferID(ScriptID& i) = 0;
 virtual int32 XferID(ScriptID *buf, int32 num) = 0;

 virtual LinkClientID XferID(LinkClientID& i) = 0;
 virtual int32 XferID(LinkClientID *buf, int32 num) = 0;


 virtual UID XferObject(UID& u) = 0;
 virtual int32 XferObject(UID *buf, int32 num) = 0;

 virtual UID XferReference(UID& u) = 0;
 virtual int32 XferReference(UID *buf, int32 num) = 0;

 virtual PMReal& XferRealNumber(PMReal& r) = 0;
 virtual int32 XferRealNumber(PMReal *buf, int32 num) = 0;

 virtual void Comment(const char* comment) = 0;

 virtual int64 Seek(int64 numberOfBytes, SeekFromWhere fromHere) = 0;
 virtual void SetEndOfStream() = 0;

 virtual void Flush() = 0;

 virtual StreamState GetStreamState() = 0;

 virtual bool16 IsReading() const = 0;
 virtual bool16 IsWriting() const = 0;

 virtual bool16 IsWritingForDuplication(IDataBase** optDestDB = nil) const = 0;

 virtual void SetSwapping(bool16 swapOn) = 0;
 virtual bool16 GetSwapping() const = 0;

 virtual bool16 Open() = 0;
 virtual void Close() = 0;

};

// specialize adobe::type_info<> to avoid typeid problems across DLL boundaries
ADOBE_NAME_TYPE_0("ipmstream:indesign:adobe",IPMStream);

namespace Persist
{
 template <typename T>
 struct Serializer
 {
 inline static void Read (IPMStream* stream, T& t)
 {
 ASSERT (stream && stream->IsReading());

 t.ReadWrite(stream);
 }

 inline static void Write (IPMStream* stream, const T& t)
 {
 ASSERT (stream && stream->IsWriting());

 // Cast constness away to to match ReadWrite signature. This should be safe since ReadWrite
 // implementations do not modify the object when the stream is being written to.
 T& tNonConst = const_cast<T&> (t);
 tNonConst.ReadWrite(stream);
 }
 };

 template<typename T>
 inline void Read (IPMStream* stream, T& t)
 {
 Serializer<T>::Read(stream, t);
 }

 template<typename T>
 inline void Write (IPMStream* stream, const T& t)
 {
 Serializer<T>::Write(stream, t);
 }
}


#endif