gzSerialize.h

Go to the documentation of this file.

// *****************************************************************************
// File         : gzSerialize.h
// Module       : gzBase
// Description  : Class definition of serialize classes
// Author       : Anders Modén      
// Product      : GizmoBase 2.1.1
//      
// Copyright © 2003- Saab Training Systems AB, Sweden       
//          
// NOTE:    GizmoBase is a platform abstraction utility layer for C++. It contains 
//          design patterns and C++ solutions for the advanced programmer.
//
//
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  981019  Created file    
//
// ******************************************************************************

#ifndef __GZ_SERIALIZE_H__
#define __GZ_SERIALIZE_H__

#include "gzBasicTypes.h"
#include "gzMemory.h"
#include "gzBase.h"
#include "gzTemplates.h"
#include "gzMatrix.h"
#include "gzMutex.h"
#include "gzGuid.h"
#include "gzXYZ.h"
#include "gzIO.h"

//#include <stdio.h>

enum gzSerializeAction { GZ_SERIALIZE_OUTPUT=1 , GZ_SERIALIZE_INPUT=2 , GZ_SERIALIZE_DUPLEX=GZ_SERIALIZE_OUTPUT|GZ_SERIALIZE_INPUT} ;

const gzString  GZ_LOG_NAME             ="gizmosdk.log";

class gzSerializeData;

const gzString  GZ_URLBASE_FILE             = "file:";  // file name
const gzString  GZ_URLBASE_HTTP             = "http:";  // http url
const gzString  GZ_URLBASE_FTP              = "ftp:";   // ftp url
const gzString  GZ_URLBASE_MEMORY           = "mem:";   // address,length
const gzString  GZ_URLBASE_REGISTRY         = "reg:";   // name of registry key
const gzString  GZ_URLBASE_ZIP              = "zip:";   // name of archive
const gzString  GZ_URLBASE_PIPE             = "pipe:";  // name of pipe
const gzString  GZ_URLBASE_PURL             = "purl:";  // "pipename","url"
const gzString  GZ_URLBASE_CONSOLE          = "con:";   // console
const gzString  GZ_URLBASE_CACHE            = "cache:"; // offset,len,url
const gzString  GZ_URLBASE_ADAPTER          = "adapt:"; // address of adapter
const gzString  GZ_URLBASE_RANDOM_ACCESS    = "rand:";  // add random access


//******************************************************************************
// Class    : gzAdapterSharedData
//                                  
// Purpose  : Utility data holder for serializing adapters
//                                  
// Notes    : -
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  010508  Created 
//                                  
//******************************************************************************
class gzAdapterSharedData : public gzReference
{
public:

    gzAdapterSharedData():index(0),size(0),saved(FALSE){};

    gzULong index;
    gzULong size;
    gzBool  saved;
};

// !Serialize Adapter loader flags
typedef gzULongLong gzSerializeAdapterFlags;

const gzSerializeAdapterFlags   GZ_SERIALIZE_ADAPTER_FLAGS_DEFAULT  =   0;
const gzSerializeAdapterFlags   GZ_SERIALIZE_ADAPTER_NO_ERROR_MSG   =   (1<<0);
const gzSerializeAdapterFlags   GZ_SERIALIZE_ADAPTER_WIDECHAR       =   (1<<1);
const gzSerializeAdapterFlags   GZ_SERIALIZE_ADAPTER_BIG_ENDIAN     =   (1<<2);


const gzULong GZ_SERIALIZE_ADAPTER_FLAG_MAX_SIZE            =   3;  // Number of flags in image flag set

//******************************************************************************
// Class    : gzSerializeURLManagerInterface
//                                  
// Purpose  : Base interface fro registered URL managers
//                                  
// Notes    : 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  060817  Created 
//                                  
//******************************************************************************
class gzSerializeURLManagerInterface : public gzReference
{
public:

    GZ_BASE_EXPORT virtual gzSerializeAdapter *getURLAdapter(const gzString &url,gzSerializeAction action,gzSerializeAdapterFlags flags, const gzString &password)=0;
};

//******************************************************************************
// Class    : gzSerializeAdapter
//                                  
// Purpose  : Base class for Serialize Adapter
//                                  
// Notes    : the gzUInt size provides for larger token sizes
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  981019  Created 
//                                  
//******************************************************************************
class  gzSerializeAdapter : public gzReference , public gzNameInterface 
{
public:

    GZ_DECLARE_TYPE_INTERFACE_EXPORT(GZ_BASE_EXPORT);   // RTTI
        
    GZ_BASE_EXPORT gzSerializeAdapter(const gzString & name);
    GZ_BASE_EXPORT gzSerializeAdapter();

    GZ_BASE_EXPORT virtual ~gzSerializeAdapter(){};

    GZ_BASE_EXPORT gzVoid   serialize(gzSerializeData *data , gzSerializeAction action);

    GZ_BASE_EXPORT gzVoid   write(gzUByte data);
    GZ_BASE_EXPORT gzUByte  read();

    GZ_BASE_EXPORT gzVoid   write(gzUByte *data,gzULong count);
    GZ_BASE_EXPORT gzULong  read(gzUByte *data,gzULong maxcount);
    
    GZ_BASE_EXPORT gzVoid   pushBack(gzUByte value);
    GZ_BASE_EXPORT gzVoid   pushBack(gzUByte *data,gzULong maxcount);

    GZ_BASE_EXPORT gzBool   hasData(gzULong mincount=1);

    GZ_BASE_EXPORT virtual  gzBool      canSeek(){ return FALSE; }
    GZ_BASE_EXPORT virtual  gzMemSize   seek(gzMemOffset offset, gzOriginPos origin=GZ_ORIGIN_SET){ return -1; }
    GZ_BASE_EXPORT virtual  gzVoid      setSeekMode(gzBool on){}

    GZ_BASE_EXPORT virtual gzBool       supportAction(gzSerializeAction action) {return TRUE;}

    GZ_BASE_EXPORT gzULong  length();
    
    GZ_BASE_EXPORT virtual  gzVoid flush();

    // ------------- Misc ------------------------------------------------------------------------------

    GZ_BASE_EXPORT gzBool   hasError();

    GZ_PROPERTY_EXPORT_I(gzString,                  Error               ,GZ_BASE_EXPORT);
    GZ_PROPERTY_EXPORT(gzSerializeAdapterFlags,     AdapterFlags        ,GZ_BASE_EXPORT);
    GZ_PROPERTY_EXPORT(gzULong,                     AdapterVersion      ,GZ_BASE_EXPORT);

    //---- Generic utilities for sharing used in serialization ------------------------------------------

    GZ_BASE_EXPORT virtual gzRefInstanceDictionary &getRefInstanceDictionary();

    GZ_BASE_EXPORT virtual gzRefInstanceArray &     getRefInstanceArray();

    GZ_BASE_EXPORT virtual gzULong                  getNewSharedInstanceID();

    GZ_BASE_EXPORT virtual gzVoid                   clearSharedRefs();
    
    GZ_BASE_EXPORT gzVoid                           copySharedRefData(const gzSerializeAdapter& inst);

    //--- Generic utils for URL management --------------------------------------------------------------

    // URL

    GZ_BASE_EXPORT gzString         getURL();

    GZ_PROPERTY_EXPORT(gzString,                    URLBase             ,GZ_BASE_EXPORT);
    GZ_PROPERTY_EXPORT(gzString,                    DefaultPath         ,GZ_BASE_EXPORT);

    // Password management
    GZ_PROPERTY_EXPORT(gzString,                    Password            ,GZ_BASE_EXPORT);

    // Controller Interface
    GZ_PROPERTY_EXPORT(gzRefPointer<gzReference>,   AssociatedData      ,GZ_BASE_EXPORT);


    //--- The VERY generic URL based adaptor factory ----------------------------------------------------

    GZ_BASE_EXPORT static gzSerializeAdapter *getURLAdapter(const gzString &url,gzSerializeAction action=GZ_SERIALIZE_INPUT,gzSerializeAdapterFlags flags=GZ_SERIALIZE_ADAPTER_FLAGS_DEFAULT, const gzString &password=GZ_EMPTY_STRING);
    GZ_BASE_EXPORT static gzVoid registerURLManager(const gzString &urlBase,gzSerializeURLManagerInterface *manager);
    GZ_BASE_EXPORT static gzVoid unregisterURLManager(const gzString &urlBase,gzSerializeURLManagerInterface *manager);


    GZ_BASE_EXPORT static gzBool    getURLBaseEncoding(const gzString &url, gzString *_urlBase=NULL,gzString *_defaultPath=NULL,gzString *_urlName=NULL,gzString *_urlAttributes=NULL);
    GZ_BASE_EXPORT static gzString  getURLAttributeValue(const gzString &attributeName,const gzString &urlAttributes);

protected:
        
    GZ_BASE_EXPORT virtual gzVoid   write_imp(gzUByte data)=0;

    GZ_BASE_EXPORT virtual gzUByte  read_imp()=0;

    GZ_BASE_EXPORT virtual gzVoid   write_imp(gzUByte *data,gzULong count);
    
    GZ_BASE_EXPORT virtual gzULong  read_imp(gzUByte *data,gzULong maxcount);
    
    GZ_BASE_EXPORT virtual gzULong  length_imp();

    GZ_BASE_EXPORT virtual gzBool   hasData_imp();

    // -----------------------------------------

    gzQueue<gzUByte>            m_pushback;
    gzString                    m_propertyError;

    // Generic adapter utilites

    gzLateBindData<gzRefInstanceDictionary> m_refDict;  // Generic dictionary
    gzLateBindData<gzRefInstanceArray>      m_refArray; // Generic array
    gzULong                                 m_counter;  // Generic counter

    static gzRefDict<gzString,gzSerializeURLManagerInterface>   s_urlManagers;
};

GZ_DECLARE_REFPTR(gzSerializeAdapter);

//******************************************************************************
// Class    : gzSerializeAdapterStdIO
//                                  
// Purpose  : Class for Serialize data to STDIO
//                                  
// Notes    : This class is responsible to write/read data to adapter
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  981019  Created 
//                                  
//******************************************************************************
class  gzSerializeAdapterStdIO : public gzSerializeAdapter
{
public:
    GZ_DECLARE_TYPE_INTERFACE_EXPORT(GZ_BASE_EXPORT);   // RTTI

    GZ_BASE_EXPORT gzSerializeAdapterStdIO():gzSerializeAdapter("StdIO"){};

    GZ_BASE_EXPORT virtual ~gzSerializeAdapterStdIO(){};

protected:
        
    GZ_BASE_EXPORT virtual gzVoid   write_imp(gzUByte data);
    GZ_BASE_EXPORT virtual gzUByte  read_imp();
    GZ_BASE_EXPORT virtual gzBool   hasData_imp();
};

//******************************************************************************
// Class    : gzSerializeAdapterMemory
//                                  
// Purpose  : Class for Serialize data to memory
//                                  
// Notes    : This class is responsible to write/read data to adapter
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  981019  Created 
//                                  
//******************************************************************************
class  gzSerializeAdapterMemory : public gzSerializeAdapter
{
public:
    GZ_DECLARE_TYPE_INTERFACE_EXPORT(GZ_BASE_EXPORT);   // RTTI

    GZ_BASE_EXPORT gzSerializeAdapterMemory(gzVoid *adress,gzULong maxlen);

    GZ_BASE_EXPORT virtual  ~gzSerializeAdapterMemory(){};

    GZ_BASE_EXPORT gzVoid   reset(gzVoid *adress=NULL,gzULong maxlen=0);

    GZ_BASE_EXPORT virtual gzVoid move(gzInt steps);

    GZ_BASE_EXPORT virtual  gzVoid flush();

protected:
        
    GZ_BASE_EXPORT virtual gzVoid   write_imp(gzUByte data);
    GZ_BASE_EXPORT virtual gzUByte  read_imp();

    GZ_BASE_EXPORT virtual gzVoid   write_imp(gzUByte *data,gzULong count);
    GZ_BASE_EXPORT virtual gzULong  read_imp(gzUByte *data,gzULong maxcount);
    GZ_BASE_EXPORT virtual gzULong  length_imp();

    gzUByte *   m_adress;
    gzULong     m_len;
    gzULong     m_currentPos;
};

GZ_DECLARE_REFPTR(gzSerializeAdapterMemory);

//******************************************************************************
// Class    : gzSerializeAdapterFile
//                                  
// Purpose  : Class for Serialize data to File
//                                  
// Notes    : This class is responsible to write/read data to adapter
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  981019  Created 
//                                  
//******************************************************************************
class  gzSerializeAdapterFile : public gzSerializeAdapter
{
public:
    GZ_DECLARE_TYPE_INTERFACE_EXPORT(GZ_BASE_EXPORT);   // RTTI

    GZ_BASE_EXPORT gzSerializeAdapterFile(const gzString &filename,gzSerializeAction action=GZ_SERIALIZE_INPUT,gzBool append=FALSE);

    GZ_BASE_EXPORT virtual ~gzSerializeAdapterFile();

    GZ_BASE_EXPORT virtual gzVoid flush();

    GZ_BASE_EXPORT virtual gzBool reset(gzULong position=0);

    GZ_BASE_EXPORT static gzVoid cleanUpLargeFiles();

    GZ_BASE_EXPORT  gzBool  readLargeChunks();
    GZ_BASE_EXPORT  gzVoid  readLargeChunks(gzBool on=TRUE);

    GZ_BASE_EXPORT virtual  gzBool canSeek();
    GZ_BASE_EXPORT virtual  gzMemSize seek(gzMemOffset offset, gzOriginPos origin=GZ_ORIGIN_SET);
    GZ_BASE_EXPORT virtual  gzVoid setSeekMode(gzBool on);

    GZ_BASE_EXPORT virtual gzBool supportAction(gzSerializeAction action);

protected:
        
    GZ_BASE_EXPORT virtual gzVoid   write_imp(gzUByte data);
    GZ_BASE_EXPORT virtual gzUByte  read_imp();

    GZ_BASE_EXPORT virtual gzVoid   write_imp(gzUByte *data,gzULong count);
    GZ_BASE_EXPORT virtual gzULong  read_imp(gzUByte *data,gzULong maxcount);
    GZ_BASE_EXPORT virtual gzULong  length_imp();

private:

    gzVoid readFileData();
    
    class gzFileQueue : public gzRecycleData<gzQueue<gzUByte> >
    {
        public:
            virtual gzVoid onInitItem(gzQueue<gzUByte> & data) const;
    };
    

    gzFileQueue             m_data;
    gzString                m_file;
    gzSerializeAction       m_mode;
    gzFileHandle            m_filehandle;
    gzULong                 m_leftOnDisc;   
    gzBool                  m_readLargeChunks;
    
};

//******************************************************************************
// Class    : gzSerializeData
//                                  
// Purpose  : Base class for Serialize data
//                                  
// Notes    : This class is responsible to write/read data to adapter
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  981019  Created 
//                                  
//******************************************************************************
class  gzSerializeData 
{
public:
    GZ_BASE_EXPORT virtual ~gzSerializeData(){};

    GZ_BASE_EXPORT virtual gzVoid write(gzSerializeAdapter *adapter)=0;

    GZ_BASE_EXPORT virtual gzVoid read(gzSerializeAdapter *adapter)=0;

    GZ_BASE_EXPORT virtual gzVoid pushBack(gzSerializeAdapter *adapter)=0;

    GZ_BASE_EXPORT virtual gzULong  getDataSize(gzSerializeAdapter *adapter=NULL) const =0;
};

//******************************************************************************
// Class    : gzSerializePacketInterface
//                                  
// Purpose  : Interface that can be implemented by some adapters
//                                  
// Notes    : 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  981019  Created 
//                                  
//******************************************************************************
class gzSerializePacketInterface
{
public:

    virtual gzULong getDroppedPackets(gzBool clearDroppedPackages=TRUE)=0;

    virtual gzDouble getAveragePacketSize()=0;

    virtual gzDouble getAveragePacketsPerSecond()=0;
};

typedef gzSerializePacketInterface * gzSerializePacketInterfacePtr;

const gzString GZ_SERIALIZE_PACKET_INTERFACE="gzSerializePacketInterface";


//******************************************************************************
// Class    : gzSerializeBinary
//                                  
// Purpose  : Template for binary storage
//                                  
// Notes    : This class is responsible to write/read data to adapter
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  990301  Created 
//                                  
//******************************************************************************
template <class T> class gzSerializeBinary : public gzSerializeData
{
public:

    explicit gzSerializeBinary<T>(  const gzBool useBigEndian=TRUE):m_useBigEnadian(useBigEndian){};

    gzBool operator==(const gzSerializeBinary<T> &right) { return m_data==right.m_data; }

    gzBool operator!=(const gzSerializeBinary<T> &right) { return m_data!=right.m_data; }

    virtual ~gzSerializeBinary<T>(){};

    virtual gzVoid write(gzSerializeAdapter *adapter);

    virtual gzVoid read(gzSerializeAdapter *adapter);

    virtual gzVoid pushBack(gzSerializeAdapter *adapter);

    virtual gzULong getDataSize(gzSerializeAdapter *adapter=NULL) const { return sizeof(m_data); }

    T & getRef()                                                        {return m_data; }

    operator  T () const                                                { return m_data; }

    T & operator = (const T &data)                                      { m_data=data; return m_data; }
    
    gzVoid setBigEndian(gzBool useBigEndian)                            { m_useBigEnadian = useBigEndian; }

private:


    T       m_data;

    gzBool  m_useBigEnadian;

};  

// Initialisation
template <> inline gzSerializeBinary<gzUByte>::gzSerializeBinary(  const gzBool useBigEndian):m_useBigEnadian(useBigEndian),m_data(0){}
template <> inline gzSerializeBinary<gzFloat>::gzSerializeBinary(  const gzBool useBigEndian):m_useBigEnadian(useBigEndian),m_data(0){}
template <> inline gzSerializeBinary<gzDouble>::gzSerializeBinary(  const gzBool useBigEndian):m_useBigEnadian(useBigEndian),m_data(0){}
template <> inline gzSerializeBinary<gzULong>::gzSerializeBinary(  const gzBool useBigEndian):m_useBigEnadian(useBigEndian),m_data(0){}
template <> inline gzSerializeBinary<gzLong>::gzSerializeBinary(  const gzBool useBigEndian):m_useBigEnadian(useBigEndian),m_data(0){}

template <class T> inline gzVoid gzSerializeBinary<T>::write(gzSerializeAdapter *adapter)
{
    gzUByte *data=(gzUByte *)&m_data;

    if(gzBigEndian())
    {
        if(m_useBigEnadian)
        {
            adapter->write(data,sizeof(m_data));
        }
        else
        {
            data+=(sizeof(m_data)-1);

            for(gzULong i=0;i<sizeof(m_data);i++)
                adapter->write(*data--);
        }
    }
    else    // Intel
    {
        if(!m_useBigEnadian)
        {
            adapter->write(data,sizeof(m_data));
        }
        else
        {
            data+=(sizeof(m_data)-1);

            for(gzULong i=0;i<sizeof(m_data);i++)
                adapter->write(*data--);
        }
    }

}

template <class T> inline gzVoid gzSerializeBinary<T>::pushBack(gzSerializeAdapter *adapter)
{
    gzUByte *data=(gzUByte *)&m_data;

    if(gzBigEndian())   // Irix etc..
    {

        if(!m_useBigEnadian)
        {
            for(gzULong i=0;i<sizeof(m_data);++i)
            {
                adapter->pushBack(*data);
                ++data;
            }
        }
        else
        {
            data+=(sizeof(m_data)-1);

            for(gzULong i=0;i<sizeof(m_data);++i)
            {
                adapter->pushBack(*data);
                --data;
            }
        }
    }
    else    // Intel
    {
        if(m_useBigEnadian)
        {
            for(gzULong i=0;i<sizeof(m_data);++i)
            {
                adapter->pushBack(*data);
                ++data;
            }
        }
        else
        {
            data+=(sizeof(m_data)-1);

            for(gzULong i=0;i<sizeof(m_data);++i)
            {
                adapter->pushBack(*data);
                --data;
            }
        }
    }
}


template <class T> inline gzVoid gzSerializeBinary<T>::read(gzSerializeAdapter *adapter)
{
    gzUByte *data=(gzUByte *)&m_data;

    if(gzBigEndian()) // Irix etc..
    {

        if(m_useBigEnadian)
        {
            adapter->read(data,sizeof(m_data));
        }
        else
        {
            data+=(sizeof(m_data)-1);

            for(gzULong i=0;i<sizeof(m_data);i++)
                *data--=adapter->read();
        }
    }
    else    // Intel
    {
        if(!m_useBigEnadian)
        {
            adapter->read(data,sizeof(m_data));
        }
        else
        {
            data+=(sizeof(m_data)-1);

            for(gzULong i=0;i<sizeof(m_data);i++)
                *data--=adapter->read();
        }

    }

}   

//******************************************************************************
// Class    : gzVarULongLong
//                                  
// Purpose  : -
//                                  
// Notes    : -
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  000531  Created 
//                                  
//******************************************************************************
class gzVarULongLong : public gzSerializeData
{
public:

    GZ_BASE_EXPORT gzVarULongLong(const gzULongLong &value=0);

    GZ_BASE_EXPORT operator gzULongLong ();

    GZ_BASE_EXPORT virtual gzVoid write(gzSerializeAdapter *adapter);

    GZ_BASE_EXPORT virtual gzVoid read(gzSerializeAdapter *adapter);

    GZ_BASE_EXPORT virtual gzVoid pushBack(gzSerializeAdapter *adapter);

    GZ_BASE_EXPORT virtual gzULong  getDataSize(gzSerializeAdapter *adapter=NULL) const ;

private:

    gzULongLong m_value;
};

//******************************************************************************
// Class    : gzSerializeArray
//                                  
// Purpose  : Template for storage of arrays of serialize data
//                                  
// Notes    : This class is responsible to write/read data to adapter
//            YOU HAVE TO SET THE SIZE before reading. No storage of size
//            See also gzSerializeBinaryArray
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  000531  Created 
//                                  
//******************************************************************************
template <class T> class gzSerializeArray : public gzSerializeData
{
public:
    
    gzSerializeArray<T>(gzULong size=0):m_data(size){};

    virtual gzVoid write(gzSerializeAdapter *adapter)
    {
        gzULong i;
        for(i=0;i<m_data.getSize();i++)
            m_data[i].write(adapter);
    }

    virtual gzVoid read(gzSerializeAdapter *adapter)
    {
        gzULong i;
        for(i=0;i<m_data.getSize();i++)
            m_data[i].read(adapter);
    }

    virtual gzVoid pushBack(gzSerializeAdapter *adapter)
    {
        gzULong i;
        for(i=0;i<m_data.getSize();i++)
            m_data[m_data.getSize()-1-i].pushBack(adapter);
    }


    virtual gzULong getDataSize(gzSerializeAdapter *adapter=NULL) const 
    {
        gzULong i,size=0;
        gzArray<T> &ptr=(gzArray<T> &)m_data;
        for(i=0;i<ptr.getSize();i++)
            size+=ptr[i].getDataSize(adapter);
        return size;
    }

    
    T & operator [](gzULong index)                                      { return m_data[index]; }

    operator const gzArray<T> & () const                                { return m_data; }

    const gzArray<T> & operator = (const gzArray<T>& data)              { m_data=data; return m_data; }

    operator    gzString ();

    gzVoid      setSize(gzULong size)                                   { m_data.setSize(size); }

    gzULong     getSize()       const                                   { return m_data.getSize(); }

private:

    gzArray<T>      m_data;

};

template <class T> inline gzSerializeArray<T>::operator gzString()
{
    gzULong len=getDataSize();

    char *buffer=new char[len+1];

    gzSerializeAdapterMemory adapter(buffer,len);

    write(&adapter);

    buffer[len]='\0';

    gzString result(buffer);

    delete [] buffer;

    return result;  // If string data contains a zero byte data it will be terminated
}

//******************************************************************************
// Class    : gzSerializeDynamicArray
//                                  
// Purpose  : Template for storage of arrays of serialize data
//                                  
// Notes    : This class is responsible to write/read data to adapter
//            YOU HAVE TO SET THE SIZE before reading. No storage of size
//            See also gzSerializeBinaryArray
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  000531  Created 
//                                  
//******************************************************************************
template <class T> class gzSerializeDynamicArray : public gzSerializeData
{
public:
    
    gzSerializeDynamicArray<T>(gzULong size=0):m_data(size){};

    virtual gzVoid write(gzSerializeAdapter *adapter)
    {
        gzULong i;
        for(i=0;i<m_data.getSize();i++)
            m_data[i].write(adapter);
    }

    virtual gzVoid read(gzSerializeAdapter *adapter)
    {
        gzULong i;
        for(i=0;i<m_data.getSize();i++)
            m_data[i].read(adapter);
    }

    virtual gzVoid pushBack(gzSerializeAdapter *adapter)
    {
        gzULong i;
        for(i=0;i<m_data.getSize();i++)
            m_data[m_data.getSize()-1-i].pushBack(adapter);
    }


    virtual gzULong getDataSize(gzSerializeAdapter *adapter=NULL) const 
    {
        gzULong i,size=0;
        gzArray<T> &ptr=(gzArray<T> &)m_data;
        for(i=0;i<ptr.getSize();i++)
            size+=ptr[i].getDataSize(adapter);
        return size;
    }

    
    T & operator [](gzULong index)                                          { return m_data[index]; }

    operator const gzDynamicArray<T> & () const                             { return m_data; }

    const gzDynamicArray<T> & operator = (const gzDynamicArray<T>& data)    { m_data=data; return m_data; }

    operator    gzString ();
    
    gzVoid      setSize(gzULong size)                                       { m_data.setSize(size); }

    gzULong     getSize()       const                                       { return m_data.getSize(); }

private:

    gzDynamicArray<T>       m_data;

};

template <class T> inline gzSerializeDynamicArray<T>::operator gzString()
{
    gzULong len=getDataSize();

    char *buffer=new char[len+1];

    gzSerializeAdapterMemory adapter(buffer,len);

    write(&adapter);

    buffer[len]='\0';

    gzString result(buffer);

    delete [] buffer;

    return result;  // If string data contains a zero byte data it will be terminated
}

//******************************************************************************
// Class    : gzSerializeString
//                                  
// Purpose  : Help class for null terminated string storage
//                                  
// Notes    : This class is responsible to write/read data to adapter
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  990401  Created 
//                                  
//******************************************************************************
class  gzSerializeString : public gzSerializeData
{
public:

    GZ_BASE_EXPORT gzSerializeString(gzUByte terminator=0):m_terminator(terminator){};

    GZ_BASE_EXPORT gzSerializeString(const gzString &string,gzUByte terminator=0):m_data(string),m_terminator(terminator){};

    GZ_BASE_EXPORT virtual ~gzSerializeString(){};

    GZ_BASE_EXPORT virtual gzVoid