Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Namespace Members | Class Members

sam_std_containers.h

00001 #ifndef s11n_SAM_STANDARD_SPECIALIZATIONS_H 00002 #define s11n_SAM_STANDARD_SPECIALIZATIONS_H 1 00003 //////////////////////////////////////////////////////////////////////// 00004 // some SAM specializations for common container types. 00005 //////////////////////////////////////////////////////////////////////// 00006 #include <s11n/class_name.h> 00007 #include <map> 00008 #include <list> 00009 #include <utility> // pair 00010 #include <vector> 00011 #include <set> 00012 00013 #include <s11n/map.h> // map/pair proxy functor 00014 #include <s11n/list.h> // list proxy functor 00015 namespace { 00016 00017 00018 //////////////////////////////////////////////////////////// 00019 // std::list 00020 template <typename ValueType> 00021 struct class_name< std::list<ValueType> > 00022 { 00023 typedef ValueType value_type; 00024 typedef std::list<ValueType> list_type; 00025 static bool cl_reg_placeholder; 00026 static const char * name() 00027 { 00028 static std::string n = 00029 std::string("std::list<") 00030 + ::classname<value_type>() 00031 + ">"; 00032 if( !cl_reg_placeholder && (cl_reg_placeholder=true) ) 00033 { 00034 s11n::classloader_register< 00035 list_type,list_type 00036 >( n ); 00037 } 00038 return n.c_str(); 00039 } 00040 }; 00041 template <typename VT> 00042 bool class_name< std::list<VT> >::cl_reg_placeholder = (::classname< std::list<VT> >(),false); 00043 00044 template <typename ValueType> 00045 struct s11n_api_marshaler< std::list<ValueType> > 00046 { 00047 typedef ValueType value_type; 00048 typedef std::list<ValueType> serializable_type; 00049 typedef s11n::list::list_serializer_proxy proxy_type; 00050 00051 /** 00052 Returns proxy_type()( dest, src ). 00053 */ 00054 template <typename NodeType> 00055 static bool serialize( NodeType &dest, const serializable_type & src ) 00056 { 00057 dest.impl_class( ::classname<serializable_type>() ); 00058 return proxy_type()( dest, src ); 00059 } 00060 00061 /** 00062 Returns proxy_type()( src, dest ). 00063 */ 00064 template <typename NodeType> 00065 static bool deserialize( const NodeType & src, serializable_type & dest ) 00066 { 00067 return proxy_type()( src, dest ); 00068 } 00069 }; 00070 // end std::list 00071 //////////////////////////////////////////////////////////// 00072 00073 //////////////////////////////////////////////////////////// 00074 // std::vector 00075 template <typename ValueType> 00076 struct class_name< std::vector<ValueType> > 00077 { 00078 typedef ValueType value_type; 00079 typedef std::vector<ValueType> vector_type; 00080 static bool cl_reg_placeholder; 00081 static const char * name() 00082 { 00083 static std::string n = 00084 std::string("std::vector<") 00085 + ::classname<value_type>() 00086 + ">"; 00087 if( !cl_reg_placeholder && (cl_reg_placeholder=true) ) 00088 { 00089 s11n::classloader_register< 00090 vector_type,vector_type 00091 >( n ); 00092 } 00093 return n.c_str(); 00094 } 00095 }; 00096 template <typename VT> 00097 bool class_name< std::vector<VT> >::cl_reg_placeholder = (::classname< std::vector<VT> >(),false); 00098 00099 template <typename ValueType> 00100 struct s11n_api_marshaler< std::vector<ValueType> > 00101 { 00102 typedef ValueType value_type; 00103 typedef std::vector<ValueType> serializable_type; 00104 typedef s11n::list::list_serializer_proxy proxy_type; 00105 00106 /** 00107 Returns proxy_type()( dest, src ). 00108 */ 00109 template <typename NodeType> 00110 static bool serialize( NodeType &dest, const serializable_type & src ) 00111 { 00112 dest.impl_class( ::classname<serializable_type>() ); 00113 return proxy_type()( dest, src ); 00114 } 00115 00116 /** 00117 Returns proxy_type()( src, dest ). 00118 */ 00119 template <typename NodeType> 00120 static bool deserialize( const NodeType & src, serializable_type & dest ) 00121 { 00122 return proxy_type()( src, dest ); 00123 } 00124 }; 00125 00126 // end std::vector 00127 //////////////////////////////////////////////////////////// 00128 00129 //////////////////////////////////////////////////////////// 00130 // std::set 00131 template <typename ValueType> 00132 struct class_name< std::set<ValueType> > 00133 { 00134 typedef ValueType value_type; 00135 typedef std::set<ValueType> set_type; 00136 static bool cl_reg_placeholder; 00137 static const char * name() 00138 { 00139 static std::string n = 00140 std::string("std::set<") 00141 + ::classname<value_type>() 00142 + ">"; 00143 if( !cl_reg_placeholder && (cl_reg_placeholder=true) ) 00144 { 00145 s11n::classloader_register< 00146 set_type,set_type 00147 >( n ); 00148 } 00149 return n.c_str(); 00150 } 00151 }; 00152 template <typename VT> 00153 bool class_name< std::set<VT> >::cl_reg_placeholder = (::classname< std::set<VT> >(),false); 00154 00155 template <typename ValueType> 00156 struct s11n_api_marshaler< std::set<ValueType> > 00157 { 00158 typedef ValueType value_type; 00159 typedef std::set<ValueType> serializable_type; 00160 typedef s11n::list::list_serializer_proxy proxy_type; 00161 00162 /** 00163 Returns proxy_type()( dest, src ). 00164 */ 00165 template <typename NodeType> 00166 static bool serialize( NodeType &dest, const serializable_type & src ) 00167 { 00168 dest.impl_class( ::classname<serializable_type>() ); 00169 return proxy_type()( dest, src ); 00170 } 00171 00172 /** 00173 Returns proxy_type()( src, dest ). 00174 */ 00175 template <typename NodeType> 00176 static bool deserialize( const NodeType & src, serializable_type & dest ) 00177 { 00178 return proxy_type()( src, dest ); 00179 } 00180 }; 00181 00182 // end std::set 00183 //////////////////////////////////////////////////////////// 00184 00185 //////////////////////////////////////////////////////////// 00186 // std::multiset 00187 template <typename ValueType> 00188 struct class_name< std::multiset<ValueType> > 00189 { 00190 typedef ValueType value_type; 00191 typedef std::multiset<ValueType> set_type; 00192 static bool cl_reg_placeholder; 00193 00194 static const char * name() 00195 { 00196 static std::string n = 00197 std::string("std::multiset<") 00198 + ::classname<value_type>() 00199 + ">"; 00200 if( !cl_reg_placeholder && (cl_reg_placeholder=true) ) 00201 { 00202 s11n::classloader_register< 00203 set_type,set_type 00204 >( n ); 00205 } 00206 return n.c_str(); 00207 } 00208 }; 00209 template <typename VT> 00210 bool class_name< std::multiset<VT> >::cl_reg_placeholder = (::classname< std::multiset<VT> >(),false); 00211 00212 template <typename ValueType> 00213 struct s11n_api_marshaler< std::multiset<ValueType> > 00214 { 00215 typedef ValueType value_type; 00216 typedef std::multiset<ValueType> serializable_type; 00217 typedef s11n::list::list_serializer_proxy proxy_type; 00218 00219 /** 00220 Returns proxy_type()( dest, src ). 00221 */ 00222 template <typename NodeType> 00223 static bool serialize( NodeType &dest, const serializable_type & src ) 00224 { 00225 dest.impl_class( ::classname<serializable_type>() ); 00226 return proxy_type()( dest, src ); 00227 } 00228 00229 /** 00230 Returns proxy_type()( src, dest ). 00231 */ 00232 template <typename NodeType> 00233 static bool deserialize( const NodeType & src, serializable_type & dest ) 00234 { 00235 return proxy_type()( src, dest ); 00236 } 00237 }; 00238 00239 // end std::multiset 00240 //////////////////////////////////////////////////////////// 00241 00242 00243 //////////////////////////////////////////////////////////// 00244 // std::pair 00245 template <typename FirstT, typename SecondT> 00246 struct class_name< std::pair<FirstT,SecondT> > 00247 { 00248 typedef FirstT first_type; 00249 typedef SecondT second_type; 00250 typedef std::pair<FirstT,SecondT> pair_type; 00251 static bool cl_reg_placeholder; 00252 00253 static const char * name() 00254 { 00255 static std::string n = 00256 std::string("std::pair<") 00257 + ::classname<first_type>() 00258 + "," 00259 + ::classname<second_type>() 00260 + ">"; 00261 if( !cl_reg_placeholder && (cl_reg_placeholder=true) ) 00262 { 00263 s11n::classloader_register< 00264 pair_type,pair_type 00265 >( n ); 00266 } 00267 return n.c_str(); 00268 } 00269 }; 00270 template <typename KT, typename MT> 00271 bool class_name< std::pair<KT,MT> >::cl_reg_placeholder = (::classname< std::pair<KT,MT> >(),false); 00272 00273 template <typename FirstT, typename SecondT> 00274 struct s11n_api_marshaler< std::pair<FirstT,SecondT> > 00275 { 00276 typedef FirstT first_type; 00277 typedef SecondT second_type; 00278 typedef std::pair<FirstT,SecondT> serializable_type; 00279 typedef s11n::map::pair_serializer_proxy proxy_type; 00280 00281 00282 /** 00283 Returns proxy_type()( dest, src ). 00284 */ 00285 template <typename NodeType> 00286 static bool serialize( NodeType &dest, const serializable_type & src ) 00287 { 00288 dest.impl_class( ::classname<serializable_type>() ); 00289 return proxy_type()( dest, src ); 00290 } 00291 00292 /** 00293 Returns proxy_type()( src, dest ). 00294 */ 00295 template <typename NodeType> 00296 static bool deserialize( const NodeType & src, serializable_type & dest ) 00297 { 00298 return proxy_type()( src, dest ); 00299 } 00300 }; 00301 // end std::pair 00302 //////////////////////////////////////////////////////////// 00303 00304 00305 //////////////////////////////////////////////////////////// 00306 // std::map 00307 template <typename KeyT, typename MappedT> 00308 struct class_name< std::map<KeyT,MappedT> > 00309 { 00310 typedef KeyT key_type; 00311 typedef MappedT mapped_type; 00312 typedef std::map<KeyT,MappedT> map_type; 00313 static bool cl_reg_placeholder; 00314 00315 static const char * name() 00316 { 00317 static std::string n = 00318 std::string("std::map<") 00319 + ::classname<key_type>() 00320 + "," 00321 + ::classname<mapped_type>() 00322 + ">"; 00323 if( !cl_reg_placeholder && (cl_reg_placeholder=true) ) 00324 { 00325 //CERR << "Registering map type ["<<n<<"]\n"; 00326 s11n::classloader_register< 00327 map_type,map_type 00328 >( n ); 00329 } 00330 return n.c_str(); 00331 } 00332 }; 00333 00334 template <typename KT, typename MT> 00335 bool class_name< std::map<KT,MT> >::cl_reg_placeholder = (::classname< std::map<KT,MT> >(),false); 00336 00337 template <typename KeyT, typename MappedT> 00338 struct s11n_api_marshaler< std::map<KeyT,MappedT> > 00339 { 00340 typedef KeyT key_type; 00341 typedef MappedT mapped_type; 00342 typedef std::map<KeyT,MappedT> serializable_type; 00343 typedef typename serializable_type::value_type pair_type; 00344 00345 typedef s11n::map::map_serializer_proxy proxy_type; 00346 00347 00348 /** 00349 Returns proxy_type()( dest, src ). 00350 */ 00351 template <typename NodeType> 00352 static bool serialize( NodeType &dest, const serializable_type & src ) 00353 { 00354 dest.impl_class( ::classname<serializable_type>() ); 00355 return proxy_type()( dest, src ); 00356 } 00357 00358 /** 00359 Returns proxy_type()( src, dest ). 00360 */ 00361 template <typename NodeType> 00362 static bool deserialize( const NodeType & src, serializable_type & dest ) 00363 { 00364 return proxy_type()( src, dest ); 00365 } 00366 }; 00367 // end std::map 00368 //////////////////////////////////////////////////////////// 00369 00370 00371 00372 00373 //////////////////////////////////////////////////////////// 00374 // std::multimap 00375 template <typename KeyT, typename MappedT> 00376 struct class_name< std::multimap<KeyT,MappedT> > 00377 { 00378 typedef KeyT key_type; 00379 typedef MappedT mapped_type; 00380 typedef std::multimap<KeyT,MappedT> map_type; 00381 static bool cl_reg_placeholder; 00382 00383 static const char * name() 00384 { 00385 static std::string n = 00386 std::string("std::multimap<") 00387 + ::classname<key_type>() 00388 + "," 00389 + ::classname<mapped_type>() 00390 + ">"; 00391 if( !cl_reg_placeholder && (cl_reg_placeholder=true) ) 00392 { 00393 s11n::classloader_register< 00394 map_type,map_type 00395 >( n ); 00396 } 00397 return n.c_str(); 00398 } 00399 }; 00400 template <typename KT, typename MT> 00401 bool class_name< std::multimap<KT,MT> >::cl_reg_placeholder = (::classname< std::multimap<KT,MT> >(),false); 00402 00403 template <typename KeyT, typename MappedT> 00404 struct s11n_api_marshaler< std::multimap<KeyT,MappedT> > 00405 { 00406 typedef KeyT key_type; 00407 typedef MappedT mapped_type; 00408 typedef std::multimap<KeyT,MappedT> serializable_type; 00409 typedef typename serializable_type::value_type pair_type; 00410 00411 typedef s11n::map::map_serializer_proxy proxy_type; 00412 00413 /** 00414 Returns proxy_type()( dest, src ). 00415 */ 00416 template <typename NodeType> 00417 static bool serialize( NodeType &dest, const serializable_type & src ) 00418 { 00419 dest.impl_class( ::classname<serializable_type>() ); 00420 return proxy_type()( dest, src ); 00421 } 00422 00423 /** 00424 Returns proxy_type()( src, dest ). 00425 */ 00426 template <typename NodeType> 00427 static bool deserialize( const NodeType & src, serializable_type & dest ) 00428 { 00429 return proxy_type()( src, dest ); 00430 } 00431 }; 00432 // end std::multimap 00433 //////////////////////////////////////////////////////////// 00434 00435 } // anonymous namespace 00436 00437 #endif // s11n_SAM_STANDARD_SPECIALIZATIONS_H

Generated on Tue Jul 20 10:46:48 2004 for s11n by doxygen 1.3.7