Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | 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 Thu Jun 16 16:18:12 2005 for s11n by  doxygen 1.4.3-20050530