#include <qfile.h>

#include <assert.h>

#include "sortdict.h"

#include "marshal.h"

#include "entry.h"

#include "section.h"

#include "memberlist.h"

#include "definition.h"

#include "groupdef.h"

#include "example.h"

#define HEADER ('D'<<24)+('O'<<16)+('X'<<8)+'!'

void marshalInt(StorageIntf *s,int v)

{

  uchar b[4];

  b[0]=((uint)v)>>24;

  b[1]=(((uint)v)>>16)&0xff;

  b[2]=(((uint)v)>>8)&0xff;

  b[3]=v&0xff;

  s->write((const char *)b,4);

}

void marshalUInt(StorageIntf *s,uint v)

{

  uchar b[4];

  b[0]=v>>24;

  b[1]=(v>>16)&0xff;

  b[2]=(v>>8)&0xff;

  b[3]=v&0xff;

  s->write((const char *)b,4);

}

void marshalBool(StorageIntf *s,bool b)

{

  char c = b;

  s->write(&c,sizeof(char));

}

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

{

  uint l=str.length();

  marshalUInt(s,l);

  if (l>0) s->write(str.data(),l);

}

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

{

  uint l=str.length();

  marshalUInt(s,l);

  if (l>0) s->write(str.data(),l);

}

void marshalArgumentList(StorageIntf *s,ArgumentList *argList)

{

  if (argList==0)

  {

    marshalUInt(s,NULL_LIST); // null pointer representation

  }

  else

  {

    marshalUInt(s,argList->count());

    if (argList->count()>0)

    {

      ArgumentListIterator ali(*argList);

      Argument *a;

      for (ali.toFirst();(a=ali.current());++ali)

      {

        marshalQCString(s,a->attrib);    

        marshalQCString(s,a->type);    

        marshalQCString(s,a->canType);    

        marshalQCString(s,a->name);    

        marshalQCString(s,a->array);    

        marshalQCString(s,a->defval);    

        marshalQCString(s,a->docs);    

      }

    }

    marshalBool(s,argList->constSpecifier);

    marshalBool(s,argList->volatileSpecifier);

    marshalBool(s,argList->pureSpecifier);

  }

}

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

{

  if (argLists==0)

  {

    marshalUInt(s,NULL_LIST); // null pointer representation

  }

  else

  {

    marshalUInt(s,argLists->count());

    QListIterator<ArgumentList> ali(*argLists);

    ArgumentList *al;

    for (ali.toFirst();(al=ali.current());++ali)

    {

      marshalArgumentList(s,al);

    }

  }

}

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

{

  if (baseList==0)

  {

    marshalUInt(s,NULL_LIST); // null pointer representation

  }

  else

  {

    marshalUInt(s,baseList->count());

    QListIterator<BaseInfo> bli(*baseList);

    BaseInfo *bi;

    for (bli.toFirst();(bi=bli.current());++bli)

    {

      marshalQCString(s,bi->name);

      marshalInt(s,(int)bi->prot);

      marshalInt(s,(int)bi->virt);

    }

  }

}

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

{

  if (groups==0)

  {

    marshalUInt(s,NULL_LIST); // null pointer representation

  }

  else

  {

    marshalUInt(s,groups->count());

    QListIterator<Grouping> gli(*groups);

    Grouping *g;

    for (gli.toFirst();(g=gli.current());++gli)

    {

      marshalQCString(s,g->groupname);

      marshalInt(s,(int)g->pri);

    }

  }

}

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

{

  if (anchors==0)

  {

    marshalUInt(s,NULL_LIST); // null pointer representation

  }

  else

  {

    marshalUInt(s,anchors->count());

    QListIterator<SectionInfo> sli(*anchors);

    SectionInfo *si;

    for (sli.toFirst();(si=sli.current());++sli)

    {

      marshalQCString(s,si->label);

      marshalQCString(s,si->title);

      marshalQCString(s,si->ref);

      marshalInt(s,(int)si->type);

      marshalQCString(s,si->fileName);

    }

  }

}

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

{

  if (sli==0)

  {

    marshalUInt(s,NULL_LIST); // null pointer representation

  }

  else

  {

    marshalUInt(s,sli->count());

    QListIterator<ListItemInfo> liii(*sli);

    ListItemInfo *lii;

    for (liii.toFirst();(lii=liii.current());++liii)

    {

      marshalQCString(s,lii->type);

      marshalInt(s,lii->itemId);

    }

  }

}

void marshalObjPointer(StorageIntf *s,void *obj)

{

  char *b = (char *)&obj;

  s->write(b,sizeof(void *));

}

void marshalSectionDict(StorageIntf *s,SectionDict *sections)

{

  if (sections==0)

  {

    marshalUInt(s,NULL_LIST); // null pointer representation

  }

  else

  {

    marshalUInt(s,sections->count());

    QDictIterator<SectionInfo> sli(*sections);

    SectionInfo *si;

    for (sli.toFirst();(si=sli.current());++sli)

    {

      marshalQCString(s,sli.currentKey());

      marshalObjPointer(s,si);

    }

  }

}

void marshalMemberSDict(StorageIntf *s,MemberSDict *memberSDict)

{

  if (memberSDict==0)

  {

    marshalUInt(s,NULL_LIST); // null pointer representation

  }

  else

  {

    marshalUInt(s,memberSDict->count());

    //printf("  marshalMemberSDict: items=%d\n",memberSDict->count());

    SDict<MemberDef>::IteratorDict mdi(*memberSDict);

    MemberDef *md;

    int count=0;

    for (mdi.toFirst();(md=mdi.current());++mdi)

    {

      //printf("  marshalMemberSDict: %d: key=%s value=%p\n",count,mdi.currentKey().data(),md);

      marshalQCString(s,mdi.currentKey());

      marshalObjPointer(s,md);

      count++;

    }

    assert(count==memberSDict->count());

  }

}

void marshalDocInfo(StorageIntf *s,DocInfo *docInfo)

{

  if (docInfo==0)

  {

    marshalUInt(s,NULL_LIST); // null pointer representation

  }

  else

  {

    marshalUInt(s,1); 

    marshalQCString(s,docInfo->doc);

    marshalInt(s,docInfo->line);

    marshalQCString(s,docInfo->file);

  }

}

void marshalBriefInfo(StorageIntf *s,BriefInfo *briefInfo)

{

  if (briefInfo==0)

  {

    marshalUInt(s,NULL_LIST); // null pointer representation

  }

  else

  {

    marshalUInt(s,1); 

    marshalQCString(s,briefInfo->doc);

    marshalQCString(s,briefInfo->tooltip);

    marshalInt(s,briefInfo->line);

    marshalQCString(s,briefInfo->file);

  }

}

void marshalBodyInfo(StorageIntf *s,BodyInfo *bodyInfo)

{

  if (bodyInfo==0)

  {

    marshalUInt(s,NULL_LIST); // null pointer representation

  }

  else

  {

    marshalUInt(s,1); 

    marshalInt(s,bodyInfo->startLine);

    marshalInt(s,bodyInfo->endLine);

    marshalObjPointer(s,bodyInfo->fileDef);

  }

}

void marshalGroupList(StorageIntf *s,GroupList *groupList)

{

  if (groupList==0)

  {

    marshalUInt(s,NULL_LIST); // null pointer representation

  }

  else

  {

    marshalUInt(s,groupList->count());

    QListIterator<GroupDef> gli(*groupList);

    GroupDef *gd=0;

    for (gli.toFirst();(gd=gli.current());++gli)

    {

      marshalObjPointer(s,gd);

    }

  }

}

void marshalMemberList(StorageIntf *s,MemberList *ml)

{

  if (ml==0)

  {

    marshalUInt(s,NULL_LIST); // null pointer representation

  }

  else

  {

    marshalUInt(s,ml->count());

    MemberListIterator mli(*ml);

    MemberDef *md;

    uint count=0;

    for (mli.toFirst();(md=mli.current());++mli)

    {

      marshalObjPointer(s,md);

      count++;

    }

    assert(count==ml->count());

    ml->marshal(s);

  }

}

void marshalExampleSDict(StorageIntf *s,ExampleSDict *ed)

{

  if (ed==0)

  {

    marshalUInt(s,NULL_LIST); // null pointer representation

  }

  else

  {

    marshalUInt(s,ed->count());

    //printf("  marshalMemberSDict: items=%d\n",memberSDict->count());

    SDict<Example>::IteratorDict edi(*ed);

    Example *e;

    for (edi.toFirst();(e=edi.current());++edi)

    {

      //printf("  marshalMemberSDict: %d: key=%s value=%p\n",count,mdi.currentKey().data(),md);

      marshalQCString(s,edi.currentKey());

      marshalQCString(s,e->anchor);

      marshalQCString(s,e->name);

      marshalQCString(s,e->file);

    }

  }

}

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

{

  if (mls==0)

  {

    marshalUInt(s,NULL_LIST); // null pointer representation

  }

  else

  {

    marshalUInt(s,mls->count());

    //printf("  marshalMemberSDict: items=%d\n",memberSDict->count());

    SDict<MemberList>::IteratorDict mli(*mls);

    MemberList *ml;

    for (mli.toFirst();(ml=mli.current());++mli)

    {

      //printf("  marshalMemberSDict: %d: key=%s value=%p\n",count,mdi.currentKey().data(),md);

      marshalQCString(s,mli.currentKey());

      marshalObjPointer(s,ml); // assume we are not owner of the list

    }

  }

}

void marshalEntry(StorageIntf *s,Entry *e)

{

  marshalUInt(s,HEADER);

  marshalQCString(s,e->name);

  marshalQCString(s,e->type);

  marshalInt(s,e->section);

  marshalInt(s,(int)e->protection);

  marshalInt(s,(int)e->mtype);

  marshalInt(s,e->spec);

  marshalInt(s,e->initLines);

  marshalBool(s,e->stat);

  marshalBool(s,e->explicitExternal);

  marshalBool(s,e->proto);

  marshalBool(s,e->subGrouping);

  marshalBool(s,e->callGraph);

  marshalBool(s,e->callerGraph);

  marshalInt(s,(int)e->virt);

  marshalQCString(s,e->args);

  marshalQCString(s,e->bitfields);

  marshalArgumentList(s,e->argList);

  marshalArgumentLists(s,e->tArgLists);

  marshalQGString(s,e->program);

  marshalQGString(s,e->initializer);

  marshalQCString(s,e->includeFile);

  marshalQCString(s,e->includeName);

  marshalQCString(s,e->doc);

  marshalInt(s,e->docLine);

  marshalQCString(s,e->docFile);

  marshalQCString(s,e->brief);

  marshalInt(s,e->briefLine);

  marshalQCString(s,e->briefFile);

  marshalQCString(s,e->inbodyDocs);

  marshalInt(s,e->inbodyLine);

  marshalQCString(s,e->inbodyFile);

  marshalQCString(s,e->relates);

  marshalInt(s,e->relatesType);

  marshalQCString(s,e->read);

  marshalQCString(s,e->write);

  marshalQCString(s,e->inside);

  marshalQCString(s,e->exception);

  marshalArgumentList(s,e->typeConstr);

  marshalInt(s,e->bodyLine);

  marshalInt(s,e->endBodyLine);

  marshalInt(s,e->mGrpId);

  marshalBaseInfoList(s,e->extends);

  marshalGroupingList(s,e->groups);

  marshalSectionInfoList(s,e->anchors);

  marshalQCString(s,e->fileName);

  marshalInt(s,e->startLine);

  marshalItemInfoList(s,e->sli);

  marshalBool(s,e->objc);

  marshalBool(s,e->hidden);

  marshalBool(s,e->artificial);

  marshalInt(s,(int)e->groupDocType);

}

void marshalEntryTree(StorageIntf *s,Entry *e)

{

  marshalEntry(s,e);

  marshalUInt(s,e->children()->count());

  QListIterator<Entry> eli(*e->children());

  Entry *child;

  for (eli.toFirst();(child=eli.current());++eli)

  {

    marshalEntryTree(s,child);

  }

}

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

int unmarshalInt(StorageIntf *s)

{

  uchar b[4];

  s->read((char *)b,4);

  int result=(int)((((uint)b[0])<<24)+((uint)b[1]<<16)+((uint)b[2]<<8)+(uint)b[3]);

  //printf("unmarshalInt: %x %x %x %x: %x offset=%llx\n",b[0],b[1],b[2],b[3],result,f.pos());

  return result;

}

uint unmarshalUInt(StorageIntf *s)

{

  uchar b[4];

  s->read((char *)b,4);

  uint result=(((uint)b[0])<<24)+((uint)b[1]<<16)+((uint)b[2]<<8)+(uint)b[3];

  //printf("unmarshalUInt: %x %x %x %x: %x offset=%llx\n",b[0],b[1],b[2],b[3],result,f.pos());

  return result;

}

bool unmarshalBool(StorageIntf *s)

{

  char result;

  s->read(&result,sizeof(result));

  //printf("unmarshalBool: %x offset=%llx\n",result,f.pos());

  return result;

}

QCString unmarshalQCString(StorageIntf *s)

{

  uint len = unmarshalUInt(s);

  //printf("unmarshalQCString: len=%d offset=%llx\n",len,f.pos());

  QCString result(len+1);

  result.at(len)='\0';

  if (len>0)

  {

    s->read(result.data(),len);

  }

  //printf("unmarshalQCString: result=%s\n",result.data());

  return result;

}

QGString unmarshalQGString(StorageIntf *s)

{

  uint len = unmarshalUInt(s);

  //printf("unmarshalQCString: len=%d offset=%llx\n",len,f.pos());

  QGString result(len+1);

  result.at(len)='\0';

  if (len>0)

  {

    s->read(result.data(),len);

  }

  //printf("unmarshalQCString: result=%s\n",result.data());

  return result;

}

ArgumentList *unmarshalArgumentList(StorageIntf *s)

{

  uint i;

  uint count = unmarshalUInt(s);

  if (count==NULL_LIST) return 0; // null list

  ArgumentList *result = new ArgumentList;

  assert(count<1000000);

  //printf("unmarshalArgumentList: %d\n",count);

  for (i=0;i<count;i++)

  {

    Argument *a = new Argument;

    a->attrib  = unmarshalQCString(s);

    a->type    = unmarshalQCString(s);

    a->canType = unmarshalQCString(s);

    a->name    = unmarshalQCString(s);

    a->array   = unmarshalQCString(s);

    a->defval  = unmarshalQCString(s);

    a->docs    = unmarshalQCString(s);

    result->append(a);

  }

  result->constSpecifier    = unmarshalBool(s);

  result->volatileSpecifier = unmarshalBool(s);

  result->pureSpecifier     = unmarshalBool(s);

  return result;

}

QList<ArgumentList> *unmarshalArgumentLists(StorageIntf *s)

{

  uint i;

  uint count = unmarshalUInt(s);

  if (count==NULL_LIST) return 0; // null list

  QList<ArgumentList> *result = new QList<ArgumentList>;

  result->setAutoDelete(TRUE);

  assert(count<1000000);

  //printf("unmarshalArgumentLists: %d\n",count);

  for (i=0;i<count;i++)

  {

    result->append(unmarshalArgumentList(s));

  }

  return result;

}