graph.h

Go to the documentation of this file.
00001 #ifndef VVELIB_STORAGE_GRAPH_STORAGE_H
00002 #define VVELIB_STORAGE_GRAPH_STORAGE_H
00003 
00008 #include <config.h>
00009 #include <storage/storage.h>
00010 #include <graph/vvgraph.h>
00011 #include <graph/vvbigraph.h>
00012 #include <iostream>
00013 
00014 namespace graph
00015 {
00016   template <typename T>
00017   Vertex<T> create_object(Vertex<T> const& v)
00018   {
00019     return v;
00020   }
00021 
00022   template <typename T>
00023   Edge<T> create_object(Edge<T> const& e)
00024   {
00025     return e;
00026   }
00027 
00028   template <typename T>
00029   bool serialization(storage::VVEStorage& store, Vertex<T>& v)
00030   {
00031     return store.reference("", "Vertex", v);
00032   }
00033 
00034   template <typename T>
00035   bool serialization(storage::VVEStorage& store, Edge<T>& e)
00036   {
00037     return store.reference("", "Edge", e);
00038   }
00039 
00040   template <typename V, typename E, bool compact>
00041   bool serialization(storage::VVEStorage& store, VVGraph<V,E,compact>& G)
00042   {
00043     typedef typename VVGraph<V,E,compact>::vertex_t vertex_t;
00044     typedef typename VVGraph<V,E,compact>::edge_t edge_t;
00045     if(store.writer())
00046     {
00047       forall(const vertex_t& v, G)
00048       {
00049         vertex_t v1 = v;
00050         if(!store.field("Vertex", v1))
00051         {
00052           return false;
00053         }
00054       }
00055       forall(const vertex_t& v, G)
00056       {
00057         if(!store.startCompound("Neighborhood"))
00058           return false;
00059         vertex_t v1 = v;
00060         if(!store.field("Source", v1))
00061         {
00062           return false;
00063         }
00064         forall(const vertex_t& n, G.neighbors(v))
00065         {
00066           vertex_t n1 = n;
00067           if(!store.field("Neighbor", n1))
00068           {
00069             return false;
00070           }
00071           edge_t e = G.edge(v,n);
00072           if(!store.field("Edge", e))
00073           {
00074             return false;
00075           }
00076         }
00077         store.endCompound();
00078       }
00079     }
00080     else if(store.reader())
00081     {
00082       G.clear();
00083       while(store.checkNextField("Vertex"))
00084       {
00085         vertex_t v;
00086         if(!store.field("Vertex", v))
00087         {
00088           return false;
00089         }
00090         G.insert(v);
00091       }
00092       for(size_t i = 0 ; i < G.size() ; ++i)
00093       {
00094         if(!store.startCompound("Neighborhood"))
00095           return false;
00096         vertex_t v1;
00097         if(!store.field("Source", v1))
00098         {
00099           return false;
00100         }
00101         const vertex_t& v = G.reference(v1);
00102         vertex_t prev(0);
00103         while(store.checkNextField("Neighbor"))
00104         {
00105           vertex_t n;
00106           if(!store.field("Neighbor", n))
00107           {
00108             return false;
00109           }
00110           edge_t e;
00111           if(prev)
00112             e = G.spliceAfter(v,prev,n);
00113           else
00114             e = G.insertEdge(v,n);
00115           if(!e)
00116           {
00117             store.setLastError(10, "Error creating an edge");
00118             return false;
00119           }
00120           prev = n;
00121           if(!store.field("Edge", e))
00122           {
00123             return false;
00124           }
00125         }
00126         store.endCompound();
00127       }
00128     }
00129     return true;
00130   }
00131 
00132   template <typename V1, typename V2, typename E1, typename E2, bool compact>
00133   bool serialization(storage::VVEStorage& store, VVBiGraph<V1,V2,E1,E2,compact>& G)
00134   {
00135     typedef typename VVBiGraph<V1,V2,E1,E2,compact>::vertex1_t vertex1_t;
00136     typedef typename VVBiGraph<V1,V2,E1,E2,compact>::edge1_t edge1_t;
00137     typedef typename VVBiGraph<V1,V2,E1,E2,compact>::vertex2_t vertex2_t;
00138     typedef typename VVBiGraph<V1,V2,E1,E2,compact>::edge2_t edge2_t;
00139     if(store.writer())
00140     {
00141       forall_named(const vertex1_t& v, G, vertex1)
00142       {
00143         vertex1_t v1 = v;
00144         if(!store.field("Vertex1", v1))
00145         {
00146           return false;
00147         }
00148       }
00149       forall_named(const vertex2_t& v, G, vertex2)
00150       {
00151         vertex2_t v1 = v;
00152         if(!store.field("Vertex2", v1))
00153         {
00154           return false;
00155         }
00156       }
00157       forall_named(const vertex1_t& v, G, vertex1)
00158       {
00159         if(!store.startCompound("Neighborhood1"))
00160           return false;
00161         vertex1_t v1 = v;
00162         if(!store.field("Source", v1))
00163         {
00164           return false;
00165         }
00166         forall(const vertex2_t& n, G.neighbors(v))
00167         {
00168           vertex2_t n1 = n;
00169           if(!store.field("Neighbor", n1))
00170           {
00171             return false;
00172           }
00173           edge1_t e = G.edge(v,n);
00174           if(!store.field("Edge", e))
00175           {
00176             return false;
00177           }
00178         }
00179         store.endCompound();
00180       }
00181       forall_named(const vertex2_t& v, G, vertex2)
00182       {
00183         if(!store.startCompound("Neighborhood2"))
00184           return false;
00185         vertex2_t v1 = v;
00186         if(!store.field("Source", v1))
00187         {
00188           return false;
00189         }
00190         forall(const vertex1_t& n, G.neighbors(v))
00191         {
00192           vertex1_t n1 = n;
00193           if(!store.field("Neighbor", n1))
00194           {
00195             return false;
00196           }
00197           edge2_t e = G.edge(v,n);
00198           if(!store.field("Edge", e))
00199           {
00200             return false;
00201           }
00202         }
00203         store.endCompound();
00204       }
00205     }
00206     else if(store.reader())
00207     {
00208       G.clear();
00209       while(store.checkNextField("Vertex1"))
00210       {
00211         vertex1_t v;
00212         if(!store.field("Vertex1", v))
00213         {
00214           return false;
00215         }
00216         G.insert(v);
00217       }
00218       while(store.checkNextField("Vertex2"))
00219       {
00220         vertex2_t v;
00221         if(!store.field("Vertex2", v))
00222         {
00223           return false;
00224         }
00225         G.insert(v);
00226       }
00227       for(size_t i = 0 ; i < G.nb_vertices1() ; ++i)
00228       {
00229         if(!store.startCompound("Neighborhood1"))
00230           return false;
00231         vertex1_t v1;
00232         if(!store.field("Source", v1))
00233         {
00234           return false;
00235         }
00236         const vertex1_t& v = G.reference(v1);
00237         vertex2_t prev(0);
00238         while(store.checkNextField("Neighbor"))
00239         {
00240           vertex2_t n;
00241           if(!store.field("Neighbor", n))
00242           {
00243             return false;
00244           }
00245           edge1_t e;
00246           if(prev)
00247             e = G.spliceAfter(v,prev,n);
00248           else
00249             e = G.insertEdge(v,n);
00250           if(!e)
00251           {
00252             store.setLastError(10, "Error creating an edge");
00253             return false;
00254           }
00255           prev = n;
00256           if(!store.field("Edge", e))
00257           {
00258             return false;
00259           }
00260         }
00261         store.endCompound();
00262       }
00263       for(size_t i = 0 ; i < G.nb_vertices2() ; ++i)
00264       {
00265         if(!store.startCompound("Neighborhood2"))
00266           return false;
00267         vertex2_t v1;
00268         if(!store.field("Source", v1))
00269         {
00270           return false;
00271         }
00272         const vertex2_t& v = G.reference(v1);
00273         vertex1_t prev(0);
00274         while(store.checkNextField("Neighbor"))
00275         {
00276           vertex1_t n;
00277           if(!store.field("Neighbor", n))
00278           {
00279             return false;
00280           }
00281           edge2_t e;
00282           if(prev)
00283             e = G.spliceAfter(v,prev,n);
00284           else
00285             e = G.insertEdge(v,n);
00286           if(!e)
00287           {
00288             store.setLastError(10, "Error creating an edge");
00289             return false;
00290           }
00291           prev = n;
00292           if(!store.field("Edge", e))
00293           {
00294             return false;
00295           }
00296         }
00297         store.endCompound();
00298       }
00299     }
00300     return true;
00301   }
00302 };
00303 
00304 #endif // VVELIB_STORAGE_GRAPH_STORAGE_H
00305 
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines
Generated on Fri May 31 15:37:50 2013 for VVE by  doxygen 1.6.3