00001 #ifndef s11n_SAM_STANDARD_SPECIALIZATIONS_H
00002 #define s11n_SAM_STANDARD_SPECIALIZATIONS_H 1
00003
00004
00005
00006 #include <s11n/class_name.h>
00007 #include <map>
00008 #include <list>
00009 #include <utility>
00010 #include <vector>
00011 #include <set>
00012
00013 #include <s11n/map.h>
00014 #include <s11n/list.h>
00015 namespace {
00016
00017
00018
00019
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
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
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
00071
00072
00073
00074
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
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
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
00127
00128
00129
00130
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
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
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
00183
00184
00185
00186
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
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
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
00240
00241
00242
00243
00244
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
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
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
00302
00303
00304
00305
00306
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
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
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
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
00368
00369
00370
00371
00372
00373
00374
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
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
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
00433
00434
00435 }
00436
00437 #endif // s11n_SAM_STANDARD_SPECIALIZATIONS_H