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