serializeaccess.h

new serializing arbitrary data structures

#ifndef SERIALIZEACCESS_H
#define SERIALIZEACCESS_H
#pragma warning(disable:4786)
#include <vector>
#include "GenericSerialize.h"
#include "Graph.h"

struct TreeAccess{//user part for tree ctrl serialization
    TreeAccess(CTreeCtrl& rTree,CArchive& rAr):tree(rTree),ar(rAr){}

    typedef HTREEITEM   Type;   //'Type' is a mandatory member of any Access class

#define TA_eRoot       0
#define TA_eChild      1
#define TA_eSibling    2
    

    CTreeCtrl&  tree;   
    CArchive&   ar;     //'ar' is a mandatory member of any Access class

    HTREEITEM   Null()const    {return NULL;}
    void        GetNeighbors(HTREEITEM current,vector< pair<Type,int> >& vecNeighbors)const
    {
        if(current==NULL){//get root items
            HTREEITEM   hItem= tree.GetRootItem();
            if(hItem){
                vecNeighbors.push_back( make_pair(hItem,TA_eRoot));
            }
        }else{
            HTREEITEM hItem= tree.GetNextSiblingItem(current);
            if(hItem){
                vecNeighbors.push_back(make_pair(hItem,TA_eSibling));
            }
            hItem= tree.GetChildItem(current);
            if(hItem){
                vecNeighbors.push_back(make_pair(hItem,TA_eChild));
            }
        }
    }
    void    SerializeThis(HTREEITEM owner,HTREEITEM current,int nTyp)const
    {
        ar  <<  tree.GetItemText(current);
        ar  <<  tree.GetItemState(current,TVIF_STATE);
    }
    HTREEITEM    DeserializeThis(HTREEITEM owner,int nTyp)const
    {
        CString strItemText;
        UINT   nState;
        ar  >> strItemText;
        ar  >> nState;

        HTREEITEM hItem;
        switch(nTyp){
        case TA_eRoot:     hItem= tree.InsertItem(strItemText);           break;
        case TA_eChild:    hItem= tree.InsertItem(strItemText,owner);     break;
        case TA_eSibling:  hItem= tree.InsertItem(strItemText,
                                    tree.GetParentItem(owner),owner);     break;
        }
        tree.SetItemData(hItem,nState);
        return hItem;
    }
    void    SetReference(HTREEITEM owner,HTREEITEM current,int nTyp)const
    {
    }
};

struct GraphAccess{//user part for graph serialization
    GraphAccess(vectorGraph& rGraph,CArchive& rAr):graph(rGraph),ar(rAr){}

    typedef Graph*   Type;      //'Type' is a mandatory member of any Access class

    vectorGraph&  graph;
    CArchive&       ar;         //'ar' is a mandatory member of any Access class

#define GA_eRoot    0
#define GA_eConnect 1

    
    Graph*  Null()const {return 0;}
    void    GetNeighbors(Graph* current,vector< pair<Type,int> >& vecNeighbors)const
    {
        if(current==NULL){//get root items
            for(unsigned i=0;i<graph.size();i++){
                vecNeighbors.push_back( make_pair(graph[i],GA_eRoot));
            }
        }else{
            for(unsigned i=0;i<current->vecConnections.size();i++){
                vecNeighbors.push_back( make_pair(graph[i],GA_eConnect));
            }
        }
    }
    void SerializeThis(Graph* owner,Graph* current,int nTyp)const
    {   
        ar  <<  current->x;
        ar  <<  current->y;
    }
    Graph* DeserializeThis(Graph* owner,int nTyp)const
    {   
        int x,y;
        ar  >>  x;
        ar  >>  y;
        graph.push_back(new Graph(x,y));
        return graph[graph.size()-1];
    }
    void SetReference(Graph* owner,Graph* current,int nTyp)const
    {
        if(owner!=0 && nTyp==GA_eConnect){
            owner->vecConnections.push_back(current);
        }
    }
};
#endif