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

s11n_core.h

00001 #ifndef s11n_S11N_CORE_INCLUDED
00002 #define s11n_S11N_CORE_INCLUDED 1
00003 
00004 ////////////////////////////////////////////////////////////////////////
00005 // s11n_core.h: some oh-so-core functions and includes
00006 // for use by s11n code.
00007 //
00008 //    Author: stephan beal <stephan@s11n.net>
00009 //    License: Public Domain
00010 ////////////////////////////////////////////////////////////////////////
00011 
00012 #include <string>
00013 #include <memory> // auto_ptr
00014 
00015 #include <s11n/cllite.h> // classloader "lite" interface
00016 #include <s11n/class_name.h> // used for getting/setting type names
00017 
00018 namespace s11n
00019 {
00020 
00021 
00022         /**
00023            Returns BaseT's classloader.
00024 
00025            See cllite::classloader() for important info.
00026         */
00027         template <typename BaseT>
00028         class_loader<BaseT> &
00029         classloader()
00030         {
00031                 return cllite::classloader<BaseT>();
00032         }
00033 
00034         /**
00035            See cllite::classload() for the docs.
00036         */
00037         template <typename BaseType>
00038         BaseType * classload( const std::string key )
00039         {
00040                 return cllite::classload<BaseType>( key );
00041         }
00042 
00043         /**
00044            Registers SubType with BaseType's classloader, using
00045            a default object factory.
00046 
00047            SubType may be the same as BaseType. If BaseType is
00048            abstract it must first be registered as an abstract base,
00049            e.g., using
00050            s11n_CLASSLOADER_ABSTRACT_BASE(BaseType), and in
00051            that case BaseType should not be registered directly with
00052            this function.
00053 
00054            Maintenance warning: see the notes in this func!
00055         */
00056         template <typename BaseType, typename SubType>
00057         void classloader_register( const std::string & classname )
00058         {
00059                 classloader<BaseType>().register_factory( classname,
00060                                                           object_factory<BaseType,SubType>::new_instance
00061                                                           // ^^^ will break of classloader changes from using object_factory
00062                                                           // for it's default factory.
00063                                                           );
00064 
00065 /**********************************************************************************
00066 // WTF??? WTF??? WTF??? WTF??? WTF??? WTF??? WTF??? WTF??? WTF???
00067 //                 typedef classloader_selector<BaseType> CLS;
00068 //                 typedef typename CLS::classloader_type CL;
00069 //                 CL::register_subtype<SubType>( classname );
00070 // why no compilie?!?!?! (gcc 3.3.1)
00071 //                 class_loader<BaseType> & cl = classloader<BaseType>();
00072 //                 cl.register_subtype<SubType>( classname );
00073 // classloader<BaseType>().register_subtype<SubType>( classname );
00074 happens on register_subtype<>().
00075    s11n::classloader_register(const std::string&)':
00076 ../../include/s11n/s11n_core.h:110: error: parse error before `>' token
00077 ../../include/s11n/s11n_core.h:111: error: parse error before `)' token
00078 
00079 Same construct compiles fine in:
00080 ./s11n/src/serializer_loader.cpp:                        this->register_subtype<compact_serializer>( "51191001" );
00081 ./s11n/src/serializer_loader.cpp:                        this->register_subtype<compact_serializer>( "51191011" );
00082 ./s11n/src/serializer_loader.cpp:                        this->register_subtype<funtxt_serializer>( "#SerialTree 1" );
00083 ./s11n/src/serializer_loader.cpp:                        this->register_subtype<funxml_serializer>( "<!DOCTYPE SerialTree>" );
00084 ./s11n/src/serializer_loader.cpp:                        this->register_subtype<hex_serializer>( "51190001" );
00085 ./s11n/src/serializer_loader.cpp:                        this->register_subtype<simplexml_serializer>( "<!DOCTYPE s11n::simplexml>" );
00086 ./s11n/src/serializer_loader.cpp:                        this->register_subtype<paren_serializer>( "(s11n::parens)" );
00087 
00088 i often have trouble calling member template funcs from gcc 3.3.1: it allows them
00089 in some contexts and not in others. AAARRRGGGG!!!!
00090 ************************************************************************/
00091         }
00092 
00093         template <typename BaseType>
00094         void classloader_register_base( const std::string & classname )
00095         {
00096                 classloader<BaseType>().register_factory( classname,
00097                                                           object_factory<BaseType,BaseType>::new_instance
00098                                                           );
00099         }
00100 
00101         template <typename BaseType>
00102         void classloader_register_abstract( const std::string & classname )
00103         {
00104                 classloader<BaseType>().register_factory( classname,
00105                                                           object_factory<BaseType,BaseType>::no_instance
00106                                                           );
00107         }
00108 
00109 } // namespace
00110 
00111 
00112 #endif // s11n_S11N_CORE_INCLUDED

Generated on Tue Oct 26 18:25:59 2004 for s11n by  doxygen 1.3.9.1