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