Serializer.h

Go to the documentation of this file.

/***************************************************************************
 * Copyright (C) 2005 by Benjamin Hadorn (bhadorn@swissinfo.org)           *
 *************************************************************************** 
 * Projekt : Zeus Base Library
 * Module  : Serializer
 * Package : System
 * Author  : Benjamin Hadorn
 * Datum   : $Date: 27.03.09 13:58 $
 * Ablage  : $File$
 * System  : Cell Computing Model
 ***************************************************************************
 * Licence:                                                                *
 *   This library is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU Lesser General Public License as        *
 *   published by the Free Software Foundation; either version             *
 *   2.1 of the License, or (at your option) any later version.            *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the          *
 *   GNU Lesser General Public License for more details.                   *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA  *
 ***************************************************************************/

/***************************************************************************
 Changes :
 $Log: /Development_F/StuderWIN/dev/Zeus/src/zeusbase/System/Serializer.h $
** 
** 1     27.03.09 13:58 Bha
** created
**
** 7     7.04.08 19:08 Bha
** Usage of GUID for Interfaces
**
** 6     7.01.08 9:01 Bha
** Serializing unsigned integers
**
** 5     3.09.07 17:21 Mabbuehl
** VS6 warnings removed.
**
** 4     3.09.07 7:04 bha
** New Framework using auto pointer and improved lists
***************************************************************************/

#ifndef SerializerH
#define SerializerH

#include <zeusbase/System/ZObject.h>
#include <zeusbase/System/ZObjectFactory.h>
#include <zeusbase/System/Interfaces/ISerializableImplHelper.hpp>
#include <zeusbase/System/Interfaces/ISerializable.hpp>
#include <zeusbase/System/ByteArrayOutputStream.h>
#include <zeusbase/System/ByteArray.hpp>

BEGIN_NAMESPACE_Zeus

class IInputStream;
class IOutputStream;
class IXMLDocument;
class TZObjectFactory;


#define CHECK_ATTRIBUTE(stream, value)    (stream.readItem() == value)
#define CHECK_INT8(stream)                CHECK_ATTRIBUTE(stream, SERIAL_INT8_ID)
#define CHECK_INT16(stream)               CHECK_ATTRIBUTE(stream, SERIAL_INT16_ID)
#define CHECK_INT32(stream)               CHECK_ATTRIBUTE(stream, SERIAL_INT32_ID)
#define CHECK_INT64(stream)               CHECK_ATTRIBUTE(stream, SERIAL_INT64_ID)
#define CHECK_UINT8(stream)               CHECK_ATTRIBUTE(stream, SERIAL_UINT8_ID)
#define CHECK_UINT16(stream)              CHECK_ATTRIBUTE(stream, SERIAL_UINT16_ID)
#define CHECK_UINT32(stream)              CHECK_ATTRIBUTE(stream, SERIAL_UINT32_ID)
#define CHECK_UINT64(stream)              CHECK_ATTRIBUTE(stream, SERIAL_UINT64_ID)
#define CHECK_FLOAT32(stream)             CHECK_ATTRIBUTE(stream, SERIAL_FLOAT32_ID)
#define CHECK_FLOAT64(stream)             CHECK_ATTRIBUTE(stream, SERIAL_FLOAT64_ID)
#define CHECK_BOOL(stream)                CHECK_ATTRIBUTE(stream, SERIAL_BOOL_ID)
#define CHECK_STRING(stream)              CHECK_ATTRIBUTE(stream, SERIAL_STRING_ID)
#define CHECK_BYTEARRAY(stream)           CHECK_ATTRIBUTE(stream, SERIAL_BYTEARRAY_ID)
#define CHECK_OBJECT(stream)              CHECK_ATTRIBUTE(stream, SERIAL_OBJECT_ID)
#define CHECK_XMLDOCUMENT(stream)         CHECK_ATTRIBUTE(stream, SERIAL_XMLDOCUMENT_ID)

//Lists
#define CHECK_OBJECTLIST(stream)          CHECK_ATTRIBUTE(stream, SERIAL_OBJECTLIST_ID)
#define CHECK_FLOAT64LIST(stream)         CHECK_ATTRIBUTE(stream, SERIAL_FLOAT64LIST_ID)

//Maps
#define CHECK_STRING_STRINGMAP(stream)    CHECK_ATTRIBUTE(stream, SERIAL_STRING_STRINGMAP_ID)




/****************************************************************************/
/****************************************************************************/
zeusbase_class TSerializer : public TZObject
{
  public:

    static void serializeBool(IOutputStream& rStreamOut, const bool bValue);
    static void serializeInt8(IOutputStream& rStreamOut, const Int8 cValue);
    static void serializeInt16(IOutputStream& rStreamOut, const Int16 sValue);
    static void serializeInt32(IOutputStream& rStreamOut, const Int32 lValue);
    static void serializeInt64(IOutputStream& rStreamOut, const Int64 ldValue);
    static void serializeUint8(IOutputStream& rStreamOut, const Uint8 ucValue);
    static void serializeUint16(IOutputStream& rStreamOut, const Uint16 usValue);
    static void serializeUint32(IOutputStream& rStreamOut, const Uint32 ulValue);
    static void serializeUint64(IOutputStream& rStreamOut, const Uint64 uldValue);
    static void serializeFloat32(IOutputStream& rStreamOut, const Float32 fValue);
    static void serializeFloat64(IOutputStream& rStreamOut, const Float64 dValue);
    static void serializeString(IOutputStream& rStreamOut, const IString& rString);
    static void serializeByteArray(IOutputStream& rStreamOut, const IByteArray& rArray);
    static void serializeObject(IOutputStream& rStreamOut, const ISerializable* pObject);
    static void serializeXMLDocument(IOutputStream& rStreamOut, const NAMESPACE_Zeus::IXMLDocument* pDocument);

    //LIST METHODS
    static void serializeObjectList(IOutputStream& rStreamOut, Int iCount);
    static void serializeObjectFromList(IOutputStream& rStreamOut, const ISerializable* pObject);
    static void serializeFloat64List(IOutputStream& rStreamOut, const IList<Float64>& rList);

    //MAP METHODS
    static void serializeStringStringMap(IOutputStream& rStreamOut, const IStringMap<TString>& rMap);


    //#######################################################################
    static Retval deserializeBool(IInputStream& rStreamIn, bool& rValue);
    static Retval deserializeInt8(IInputStream& rStreamIn, Int8& rValue);
    static Retval deserializeInt16(IInputStream& rStreamIn, Int16& rValue);
    static Retval deserializeInt32(IInputStream& rStreamIn, Int32& rValue);
    static Retval deserializeInt64(IInputStream& rStreamIn, Int64& rValue);
    static Retval deserializeUint8(IInputStream& rStreamIn, Uint8& rValue);
    static Retval deserializeUint16(IInputStream& rStreamIn, Uint16& rValue);
    static Retval deserializeUint32(IInputStream& rStreamIn, Uint32& rValue);
    static Retval deserializeUint64(IInputStream& rStreamIn, Uint64& rValue);
    static Retval deserializeFloat32(IInputStream& rStreamIn, Float32& rValue);
    static Retval deserializeFloat64(IInputStream& rStreamIn, Float64& rValue);
    static Retval deserializeString(IInputStream& rStreamIn, IString& rString);
    static Retval deserializeByteArray(IInputStream& rStreamIn, IByteArray& rArray);
    static Retval deserializeObject(IInputStream& rStreamIn, const InterfaceID& rInterfaceID, IZUnknown*& rpObject);
    static Retval deserializeXMLDocument(IInputStream& rStreamIn, NAMESPACE_Zeus::IXMLDocument*& rpDocument);

    //LIST METHODS
    static Retval deserializeObjectFromList(IInputStream& rStreamIn, const InterfaceID& rInterfaceID, IZUnknown*& rpObject);
    static Retval deserializeObjectList(IInputStream& rStreamIn, Int& rCount);
    static Retval deserializeFloat64List(IInputStream& rStreamIn, IList<Float64>& rList);

    //MAP METHODS
    static Retval deserializeStringStringMap(IInputStream& rStreamIn, IStringMap<TString>& rMap);

  private:
    static void serializeObject_internal(IOutputStream& pStreamOut, const ISerializable* pObject, bool bDoWriteID);
    static Retval deserializeObject_internal(IInputStream& pStreamIn, const InterfaceID& rInterfaceID, IZUnknown*& rpObject, bool bDoReadID);
};


/*****************************************************************************/
/*****************************************************************************/
/*static*/ inline void TSerializer::serializeBool(IOutputStream& rStreamOut, const bool bValue)
{
  rStreamOut.writeInt8(SERIAL_BOOL_ID);
  rStreamOut.writeBool(bValue);
}

/*****************************************************************************/
/*****************************************************************************/
/*static*/ inline void TSerializer::serializeInt8(IOutputStream& rStreamOut, const Int8 cValue)
{
  rStreamOut.writeInt8(SERIAL_INT8_ID);
  rStreamOut.writeInt8(cValue);
}

/*****************************************************************************/
/*****************************************************************************/
/*static*/ inline void TSerializer::serializeInt16(IOutputStream& rStreamOut, const Int16 sValue)
{
  rStreamOut.writeInt8(SERIAL_INT16_ID);
  rStreamOut.writeInt32(sValue);
}

/*****************************************************************************/
/*****************************************************************************/
/*static*/ inline void TSerializer::serializeInt32(IOutputStream& rStreamOut, const Int32 lValue)
{
  rStreamOut.writeInt8(SERIAL_INT32_ID);
  rStreamOut.writeInt32(lValue);
}

/*****************************************************************************/
/*****************************************************************************/
/*static*/ inline void TSerializer::serializeInt64(IOutputStream& rStreamOut, const Int64 ldValue)
{
  rStreamOut.writeInt8(SERIAL_INT64_ID);
  rStreamOut.writeInt32((Int32)ldValue); //TODO
}

/*****************************************************************************/
/*****************************************************************************/
/*static*/ inline void TSerializer::serializeUint8(IOutputStream& rStreamOut, const Uint8 ucValue)
{
  rStreamOut.writeInt8(SERIAL_UINT8_ID);
  rStreamOut.writeInt8(ucValue);
}

/*****************************************************************************/
/*****************************************************************************/
/*static*/ inline void TSerializer::serializeUint16(IOutputStream& rStreamOut, const Uint16 usValue)
{
  rStreamOut.writeInt8(SERIAL_UINT16_ID);
  rStreamOut.writeInt32(usValue);
}

/*****************************************************************************/
/*****************************************************************************/
/*static*/ inline void TSerializer::serializeUint32(IOutputStream& rStreamOut, const Uint32 ulValue)
{
  rStreamOut.writeInt8(SERIAL_UINT32_ID);
  rStreamOut.writeInt32(ulValue);
}

/*****************************************************************************/
/*****************************************************************************/
/*static*/ inline void TSerializer::serializeUint64(IOutputStream& rStreamOut, const Uint64 uldValue)
{
  rStreamOut.writeInt8(SERIAL_UINT64_ID);
  rStreamOut.writeInt32((Uint32)uldValue); //TODO
}

/*****************************************************************************/
/*****************************************************************************/
/*static*/ inline void TSerializer::serializeFloat32(IOutputStream& rStreamOut, const Float32 fValue)
{
  rStreamOut.writeInt8(SERIAL_FLOAT32_ID);
  rStreamOut.writeFloat64(fValue);
}

/*****************************************************************************/
/*****************************************************************************/
/*static*/ inline void TSerializer::serializeFloat64(IOutputStream& rStreamOut, const Float64 dValue)
{
  rStreamOut.writeInt8(SERIAL_FLOAT64_ID);
  rStreamOut.writeFloat64(dValue);
}

/*****************************************************************************/
/*****************************************************************************/
/*static*/ inline void TSerializer::serializeString(IOutputStream& rStreamOut, const IString& rString)
{
  rStreamOut.writeInt8(SERIAL_STRING_ID);
  rStreamOut.writeString(rString);
}

/*****************************************************************************/
/*****************************************************************************/
/*static*/ inline void TSerializer::serializeByteArray(IOutputStream& rStreamOut, const IByteArray& rArray)
{
  rStreamOut.writeInt8(SERIAL_BYTEARRAY_ID);
  rStreamOut.writeArray(rArray);
}

/*****************************************************************************/
/* serializes an object
*/
/*****************************************************************************/
/*static*/ inline void TSerializer::serializeObject(IOutputStream& rStreamOut, const ISerializable* pObject)
{
  serializeObject_internal(rStreamOut, pObject, true);
}

//LIST METHODS
/*****************************************************************************/
/*****************************************************************************/
/*static*/ inline void TSerializer::serializeObjectList(IOutputStream& rStreamOut, Int iCount)
{
  rStreamOut.writeInt8(SERIAL_OBJECTLIST_ID);
  rStreamOut.writeInt32(iCount);
}

/*****************************************************************************/
/*****************************************************************************/
/*static*/ inline void TSerializer::serializeObjectFromList(IOutputStream& rStreamOut, const ISerializable* pObject)
{
  serializeObject_internal(rStreamOut, pObject, false);
}

/*****************************************************************************/
/*****************************************************************************/
/*static*/ inline Retval TSerializer::deserializeBool(IInputStream& rStreamIn, bool& rValue)
{
  Retval retValue = RET_SERIALIZEPARSING_FAILED;
  if (CHECK_BOOL(rStreamIn))
  {
    rValue = rStreamIn.readBool(NULL);
    retValue = RET_NOERROR;
  }
  return retValue;
}

/*****************************************************************************/
/*****************************************************************************/
/*static*/ inline Retval TSerializer::deserializeInt8(IInputStream& rStreamIn, Int8& rValue)
{
  Retval retValue = RET_SERIALIZEPARSING_FAILED;
  if (CHECK_INT8(rStreamIn))
  {
    rValue = rStreamIn.readInt8(NULL);
    retValue = RET_NOERROR;
  }
  return retValue;
}

/*****************************************************************************/
/*****************************************************************************/
/*static*/ inline Retval TSerializer::deserializeInt16(IInputStream& rStreamIn, Int16& rValue)
{
  Retval retValue = RET_SERIALIZEPARSING_FAILED;
  if (CHECK_INT16(rStreamIn))
  {
    rValue = (Int16)rStreamIn.readInt32(NULL);
    retValue = RET_NOERROR;
  }
  return retValue;
}

/*****************************************************************************/
/*****************************************************************************/
/*static*/ inline Retval TSerializer::deserializeInt32(IInputStream& rStreamIn, Int32& rValue)
{
  Retval retValue = RET_SERIALIZEPARSING_FAILED;
  if (CHECK_INT32(rStreamIn))
  {
    rValue = rStreamIn.readInt32(NULL);
    retValue = RET_NOERROR;
  }
  return retValue;
}

/*****************************************************************************/
/*****************************************************************************/
/*static*/ inline Retval TSerializer::deserializeInt64(IInputStream& rStreamIn, Int64& rValue)
{
  Retval retValue = RET_SERIALIZEPARSING_FAILED;
  if (CHECK_INT64(rStreamIn))
  {
    rValue = rStreamIn.readInt32(NULL);
    retValue = RET_NOERROR;
  }
  return retValue;
}

/************************************************************************/
/*****************************************************************************/
/*static*/ inline Retval TSerializer::deserializeUint8(IInputStream& rStreamIn, Uint8& rValue)
{
  Retval retValue = RET_SERIALIZEPARSING_FAILED;
  if (CHECK_UINT8(rStreamIn))
  {
    rValue = rStreamIn.readInt8(NULL);
    retValue = RET_NOERROR;
  }
  return retValue;
}

/************************************************************************/
/*****************************************************************************/
/*static*/ inline Retval TSerializer::deserializeUint16(IInputStream& rStreamIn, Uint16& rValue)
{
  Retval retValue = RET_SERIALIZEPARSING_FAILED;
  if (CHECK_UINT16(rStreamIn))
  {
    rValue = (Int16)rStreamIn.readInt32(NULL);
    retValue = RET_NOERROR;
  }
  return retValue;
}

/************************************************************************/
/*****************************************************************************/
/*static*/ inline Retval TSerializer::deserializeUint32(IInputStream& rStreamIn, Uint32& rValue)
{
  Retval retValue = RET_SERIALIZEPARSING_FAILED;
  if (CHECK_UINT32(rStreamIn))
  {
    rValue = rStreamIn.readInt32(NULL);
    retValue = RET_NOERROR;
  }
  return retValue;
}

/************************************************************************/
/*****************************************************************************/
/*static*/ inline Retval TSerializer::deserializeUint64(IInputStream& rStreamIn, Uint64& rValue)
{
  Retval retValue = RET_SERIALIZEPARSING_FAILED;
  if (CHECK_UINT64(rStreamIn))
  {
    rValue = rStreamIn.readInt32(NULL);
    retValue = RET_NOERROR;
  }
  return retValue;
}

/*****************************************************************************/
/*****************************************************************************/
/*static*/ inline Retval TSerializer::deserializeFloat32(IInputStream& rStreamIn, Float32& rValue)
{
  Retval retValue = RET_SERIALIZEPARSING_FAILED;
  if (CHECK_FLOAT32(rStreamIn))
  {
    rValue = (Float32) rStreamIn.readFloat64(NULL);
    retValue = RET_NOERROR;
  }
  return retValue;
}

/*****************************************************************************/
/*****************************************************************************/
/*static*/ inline Retval TSerializer::deserializeFloat64(IInputStream& rStreamIn, Float64& rValue)
{
  Retval retValue = RET_SERIALIZEPARSING_FAILED;
  if (CHECK_FLOAT64(rStreamIn))
  {
    rValue = rStreamIn.readFloat64(NULL);
    retValue = RET_NOERROR;
  }
  return retValue;
}

/*****************************************************************************/
/*****************************************************************************/
/*static*/ inline Retval TSerializer::deserializeString(IInputStream& rStreamIn, IString& rString)
{
  Retval retValue = RET_SERIALIZEPARSING_FAILED;
  if (CHECK_STRING(rStreamIn) && rStreamIn.readString(rString) == RET_NOERROR)
  {
    retValue = RET_NOERROR;
  }
  return retValue;
}

/*****************************************************************************/
/*****************************************************************************/
/*static*/ inline Retval TSerializer::deserializeByteArray(IInputStream& rStreamIn, IByteArray& rArray)
{
  Retval retValue = RET_SERIALIZEPARSING_FAILED;
  if (CHECK_BYTEARRAY(rStreamIn) && rStreamIn.readArray(rArray) == RET_NOERROR)
  {
    retValue = RET_NOERROR;
  }
  return retValue;
}


/*****************************************************************************/
/*****************************************************************************/
/*static*/ inline Retval TSerializer::deserializeObject(IInputStream& rStreamIn, const InterfaceID& rInterfaceID, IZUnknown*& rpObject)
{
  return deserializeObject_internal(rStreamIn, rInterfaceID, rpObject, true);
}

/*****************************************************************************/
/*****************************************************************************/
/*static*/ inline Retval TSerializer::deserializeObjectFromList(IInputStream& rStreamIn, const InterfaceID& rInterfaceID, IZUnknown*& rpObject)
{
  return deserializeObject_internal(rStreamIn, rInterfaceID, rpObject, false);
}

/*****************************************************************************/
/*****************************************************************************/
/*static*/ inline Retval TSerializer::deserializeObjectList(IInputStream& rStreamIn, Int& rCount)
{
  Retval retValue = RET_SERIALIZEPARSING_FAILED;
  if (CHECK_OBJECTLIST(rStreamIn))
  {
    bool bError = false;
    rCount = rStreamIn.readInt32(&bError);
    if (!bError)
    {
      retValue = RET_NOERROR;
    }
  }
  return retValue;
}


END_NAMESPACE_Zeus

#endif

---

Written by Benjamin Hadorn http://www.xatlantis.ch.
Last change made on Wed Oct 28 21:42:30 2009