#ifndef MARSHAL_H

#define MARSHAL_H

#include <qlist.h>

#include <qfile.h>

#include "sortdict.h"

#include "store.h"

class ArgumentList;

struct BaseInfo;

struct Grouping;

struct SectionInfo;

struct ListItemInfo;

class QCString;

class QGString;

class SectionDict;

class MemberSDict;

class GroupList;

struct BodyInfo;

struct DocInfo;

struct BriefInfo;

class MemberList;

class ExampleSDict;

class Entry;

#define NULL_LIST 0xffffffff

class FileStorage : public QFile, public StorageIntf

{

  public:

    FileStorage() : QFile() {}

    FileStorage( const QString &name) : QFile(name) {}

    int read(char *buf,uint size)        { return QFile::readBlock(buf,size); }

    int write(const char *buf,uint size) { return QFile::writeBlock(buf,size); }

};

class StreamStorage : public StorageIntf

{

  public:

    StreamStorage()

    {

      m_data=0;

      m_offset=0;

      m_len=0;

    }

   ~StreamStorage()

    {

      delete m_data;

    }

    StreamStorage(char *data,uint len)

    {

      m_data=data;

      m_offset=0;

      m_len=len;

    }

    int read(char *buf,uint size)

    {

      int bytesLeft = QMIN((int)size,m_len-m_offset);

      if (bytesLeft>0) memcpy(buf,m_data,bytesLeft);

      m_offset+=bytesLeft;

      return bytesLeft;

    }

    int write(const char *buf,uint size)

    {

      m_data=(char *)realloc(m_data,m_offset+size);

      memcpy(m_data+m_offset,buf,size);

      m_offset+=size;

      m_len+=size;

      return size;

    }

    void rewind() { m_offset=0; }

    char *data() const { return m_data; }

    int size() { return m_len; }

  private:

    char *m_data;

    int m_offset;

    int m_len;

};

//----- marshaling function: datatype -> byte stream --------------------

void marshalInt(StorageIntf *s,int v);

void marshalUInt(StorageIntf *s,uint v);

void marshalBool(StorageIntf *s,bool b);

void marshalQCString(StorageIntf *s,const QCString &str);

void marshalQGString(StorageIntf *s,const QGString &str);

void marshalArgumentList(StorageIntf *s,ArgumentList *argList);

void marshalArgumentLists(StorageIntf *s,QList<ArgumentList> *argLists);

void marshalBaseInfoList(StorageIntf *s, QList<BaseInfo> *baseList);

void marshalGroupingList(StorageIntf *s, QList<Grouping> *groups);

void marshalSectionInfoList(StorageIntf *s, QList<SectionInfo> *anchors);

void marshalItemInfoList(StorageIntf *s, QList<ListItemInfo> *sli);

void marshalObjPointer(StorageIntf *s,void *obj);

void marshalSectionDict(StorageIntf *s,SectionDict *sections);

void marshalMemberSDict(StorageIntf *s,MemberSDict *memberSDict);

void marshalDocInfo(StorageIntf *s,DocInfo *docInfo);

void marshalBriefInfo(StorageIntf *s,BriefInfo *briefInfo);

void marshalBodyInfo(StorageIntf *s,BodyInfo *bodyInfo);

void marshalGroupList(StorageIntf *s,GroupList *groupList);

void marshalMemberList(StorageIntf *s,MemberList *ml);

void marshalExampleSDict(StorageIntf *s,ExampleSDict *ed);

void marshalMemberLists(StorageIntf *s,SDict<MemberList> *mls);

void marshalEntry(StorageIntf *s,Entry *e);

void marshalEntryTree(StorageIntf *s,Entry *e);

//----- unmarshaling function: byte stream -> datatype ------------------

int                  unmarshalInt(StorageIntf *s);

uint                 unmarshalUInt(StorageIntf *s);

bool                 unmarshalBool(StorageIntf *s);

QCString             unmarshalQCString(StorageIntf *s);

QGString             unmarshalQGString(StorageIntf *s);

ArgumentList *       unmarshalArgumentList(StorageIntf *s);

QList<ArgumentList> *unmarshalArgumentLists(StorageIntf *s);

QList<BaseInfo> *    unmarshalBaseInfoList(StorageIntf *s);

QList<Grouping> *    unmarshalGroupingList(StorageIntf *s);

QList<SectionInfo> * unmarshalSectionInfoList(StorageIntf *s);

QList<ListItemInfo> *unmarshalItemInfoList(StorageIntf *s);

void *               unmarshalObjPointer(StorageIntf *s);

SectionDict *        unmarshalSectionDict(StorageIntf *s);

MemberSDict *        unmarshalMemberSDict(StorageIntf *s);

DocInfo *            unmarshalDocInfo(StorageIntf *s);

BriefInfo *          unmarshalBriefInfo(StorageIntf *s);

BodyInfo *           unmarshalBodyInfo(StorageIntf *s);

GroupList *          unmarshalGroupList(StorageIntf *s);

MemberList *         unmarshalMemberList(StorageIntf *s);

ExampleSDict *       unmarshalExampleSDict(StorageIntf *s);

SDict<MemberList> *  unmarshalMemberLists(StorageIntf *s);

Entry *              unmarshalEntry(StorageIntf *s);

Entry *              unmarshalEntryTree(StorageIntf *s);

#endif