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