s11nlite.hpp

Go to the documentation of this file.
00001 #ifndef S11N_LITE_H_INCLUDED
00002 #define S11N_LITE_H_INCLUDED 1
00003 
00004 ////////////////////////////////////////////////////////////////////////
00005 // headers which want to check for s11nlite's inclusion should check
00006 // for:
00007 #define s11n_S11NLITE_INCLUDED 1
00008 // That's "the official way" to know if s11nlite is avaliable.
00009 ////////////////////////////////////////////////////////////////////////
00010 
00011 /**
00012    s11nlite is a simplified subset of the s11n interface, combining
00013    the APIs from the core and the s11n::io namespace into a single
00014    API. It refines the s11n interface to almost-minimal, while still
00015    leaving the full power of the underlying framework at clients'
00016    disposals if they need it. It also provides a binding to the
00017    default i/o implementation (the s11n::io-related Serializers),
00018    meaning that clients don't have to deal with file formats at all,
00019    and almost never even need to deal with the Serializer interface.
00020 
00021    It is completely compatible with the core s11n framework, but
00022    directly provides only a subset of the interface: those operations
00023    common to most client-side use-cases, and those functions where
00024    s11nlite can eliminate one of the required template parameters
00025    (s11n's conventional NodeType argument, which s11nlite hard-codes
00026    in its note_type typedef).
00027 
00028    This implementation can easily be used as a basis for writing
00029    custom client-side, s11n-based serialization frameworks.
00030 
00031    Suggestions for including specific features into this interface are
00032    of course welcomed.
00033 
00034    Common conventions concerning this API:
00035 
00036    - node_type must conform to s11n's S11n Node conventions.
00037 
00038    - node_traits is equivalent to s11n::node_traits<node_type>.
00039 
00040    - Serializers usable by this framework must be classloadable via
00041      the serializer_interface classloader (including all that this
00042      implies).
00043 
00044 
00045      As of version 1.1, s11nlite is primarily a wrapper around the
00046      type s11nlite::client_api<>. Many of s11nlite's functions
00047      internally use a client_api instance to do their work. This
00048      allows clients to swap out most of the s11nlite implementation
00049      with their own at runtime, while still allowing all s11nlite
00050      clients to use the same front-end API.
00051 
00052 
00053      License: Do As You Damned Well Please
00054 
00055      Author: stephan@s11n.net
00056 */
00057 namespace s11nlite { /** here to please doxygen :( */ }
00058 
00059 #include <memory> // auto_ptr
00060 #include <iterator> // insert_interator<>
00061 
00062 #include <s11n.net/s11n/s11n.hpp> // the core s11n framework
00063 #include <s11n.net/s11n/io/data_node_io.hpp> // s11n::io::data_node_serializer class
00064 #include <s11n.net/s11n/client_api.hpp> // the "real" implementation for most of s11nlite.
00065 
00066 
00067 namespace s11nlite {
00068 
00069 
00070 
00071     /**
00072        client_interface defines the interface used/returned by the
00073        instance() functions. By subclassing this type and
00074        reimplmenting the appropriate virtual functions, a client-supplied
00075        instance of this type can be plugged in as the primary s11nlite API
00076        handler. This allows, for example, transparently adding compression
00077        or network support to s11nlite.
00078     */
00079     typedef client_api<s11n::s11n_node> client_interface;
00080 
00081         /**
00082            node_type is the type used to store/load a Serializable
00083            object's data.
00084 
00085        FYI: node_type might change to s11n::s11n_node in 1.1,
00086        because that implementation is a tiny bit more lightweight
00087        than s11n::data_node, and was designed specifically with
00088        node_traits in mind (data_node came much earlier than
00089        either of them).  If you only use node_traits to access
00090        nodes' data then your code will be oblivious to this change
00091        (but will need a recompile).
00092         */
00093         typedef client_interface::node_type node_type;
00094 
00095         /** The s11n::node_traits type for node_type. */
00096         typedef client_interface::node_traits node_traits;
00097 
00098         /**
00099            This is the base-most type of the serializers used by s11nlite.
00100         */
00101         typedef client_interface::serializer_interface serializer_interface;
00102 
00103     /**
00104        Returns the client_interface object used by the s11nlite
00105        API. There is guaranteed to return *some* object, except
00106        possibly post-main() (where all bets are off).
00107 
00108        See instance(client_interface*) for more details.
00109     */
00110     client_interface & instance();
00111 
00112     /**
00113        Sets the client_interface object used by the s11nlite
00114        API. Ownership of newinstance IS NOT transfered. Passing
00115        NULL will cause it to revert to the default instance.
00116        newinstance must live as long as any client is using
00117        s11nlite, and when newinstance is destroyed, 0 must be
00118        passed to this function to disassociate the object from the
00119        library.
00120     */
00121     void instance( client_interface * newinstance );
00122 
00123         /**
00124            Returns a new instance of the default serializer class.
00125 
00126            The caller owns the returned pointer.
00127 
00128          */
00129         serializer_interface * create_serializer();
00130 
00131         /**
00132            Returns a new instance of the given serializer class, or 0
00133            if one could not be loaded. classname must represent a subtype
00134            of serializer_interface.
00135 
00136            The caller owns the returned pointer.
00137 
00138            You can also pass a serializer's cookie here, and that
00139            should return the same thing as its class name would.
00140 
00141            The internally-supported serializes all support a "friendly
00142            form" of the name, an alias registered with their
00143            classloader. Passing either this name or the cookie of the
00144            Serializer should return the same thing as the classname
00145            itself would.
00146 
00147            Short-form names of internally-supported Serializers:
00148 
00149            - compact (also called 51191011)
00150            - expat (IF s11n was built with libexpat support)
00151            - funtxt
00152            - funxml
00153            - parens
00154            - simplexml
00155            - wesnoth
00156 
00157            Note that the short-form name is always the same as that of
00158            the underlying Serializer class, minus the _serializer
00159            suffix. This is purely a convention, and not a rule. This command
00160        will use s11n::plugin support, if available, to dynamically
00161        load new serializers. Simply name the DLL the same as the class,
00162        without any namespace part in the filename, and your platform-specific
00163        DLL file extension (e.g. .dll, .so, or .dynlib).
00164          */
00165         serializer_interface *
00166         create_serializer( const std::string & classname );
00167 
00168 
00169         /**
00170            Sets the current Serializer class used by s11nlite's
00171            create_serializer(). Pass it a class name, or one of the
00172            convenience names listed in create_serializer(string).
00173         */
00174         void serializer_class( const std::string & );
00175 
00176         /**
00177            Gets the name of the current Serializer type.
00178         */
00179         std::string serializer_class();
00180 
00181 
00182         /**
00183            A non-const overload. Ownership is not modified by calling
00184            this function: normally the parent node owns it.
00185         */
00186         node_type *
00187         find_child( node_type & parent,
00188                     const std::string subnodename );
00189 
00190         /**
00191            Equivalent to s11n::find_child_by_name( parent, subnodename ).
00192         */
00193         const node_type *
00194         find_child( const node_type & parent,
00195                     const std::string subnodename );
00196 
00197         /**
00198            See s11n::serialize().
00199         */
00200         template <typename SerializableType>
00201         bool serialize( node_type & dest,
00202                         const SerializableType & src )
00203         {
00204                 return instance().template serialize<SerializableType>( dest, src );
00205         }
00206 
00207         /**
00208            See s11n::serialize().
00209         */
00210         template <typename SerializableType>
00211         bool serialize_subnode( node_type & dest,
00212                                 const std::string & subnodename,
00213                                 const SerializableType & src )
00214         {
00215         return instance().template serialize_subnode<SerializableType>( dest, subnodename, src );
00216         }
00217 
00218        
00219         /**
00220         Saves the given node to the given ostream using the default
00221         serializer type.
00222 
00223         Returns true on success, false on error.
00224 
00225         ONLY use this for saving root nodes!
00226         */
00227         bool save( const node_type & src, std::ostream & dest );
00228 
00229         /**
00230         Saves the given node to the given filename using the default
00231         serializer type.
00232 
00233         Returns true on success, false on error.
00234 
00235         ONLY use this for saving root nodes!
00236         */
00237         bool save( const node_type & src, const std::string & filename );
00238 
00239         /**
00240         Saves the given Serializable to the given ostream using the default
00241         serializer type.
00242 
00243         Returns true on success, false on error.
00244 
00245         ONLY use this for saving root nodes!
00246         */
00247         template <typename SerializableType>
00248         bool save( const SerializableType & src, std::ostream & dest )
00249         {
00250         return instance().template save<SerializableType>( src, dest );
00251         }
00252         /**
00253         Saves the given Serializable to the given filename using the default
00254         serializer type.
00255         
00256         Returns true on success, false on error.
00257 
00258         ONLY use this for saving root nodes!
00259         */
00260         template <typename SerializableType>
00261         bool save( const SerializableType & src, const std::string & dest )
00262         {
00263         return instance().template save<SerializableType>(src,dest);
00264         }
00265 
00266         /**
00267            Tries to load a node from the given filename.
00268 
00269            The caller owns the returned pointer.
00270          */        
00271         node_type * load_node( const std::string & src );
00272 
00273         /**
00274            Tries to load a node from the given input stream.
00275 
00276            The caller owns the returned pointer.
00277 
00278            Only usable for loading ROOT nodes.
00279          */        
00280         node_type * load_node( std::istream & src );
00281 
00282 
00283 
00284 
00285 // unnecessary with 1.1.3's functors:
00286 //         /**
00287 //            deserializer is a functor for deserializing
00288 //            SerializableType objects from node_type objects.
00289 //            Sometimes this may be more convenient to use than
00290 //            deserialize(), e.g., when deserializing multiple
00291 //            objects of the same type.
00292 //            Sample usage:
00293 // <pre>
00294 // typedef deserializer<MyBaseType> Deser;
00295 // Deser d;
00296 // MyBaseType * obj = d( my_data_node );
00297 // </pre>
00298 //         */
00299 //         template <typename SerializableType>
00300 //         struct node_deserializer
00301 //         {
00302 //                 typedef SerializableType serializable_type;
00303 //                 serializable_type * operator()( const node_type & src )
00304 //                 {
00305 //                         return s11n::deserialize<node_type,serializable_type>( src );
00306 //                 }
00307 //         };
00308 
00309         /**
00310        See s11n::deserialize().
00311 
00312            ACHTUNG: if you are using both s11n and s11nlite
00313            namespaces this function will be ambiguous with one provided
00314            in the namespace s11n. You must then qualify it
00315            with the namespace of the one you wish to use.
00316         */
00317         template <typename SerializableType>
00318         SerializableType * deserialize( const node_type & src )
00319         {
00320                 return instance().template deserialize<SerializableType>( src );
00321         }
00322 
00323 
00324 
00325         /**
00326            Tries to deserialize src into target. Returns true on
00327            success. If false is returned then target is not guaranteed
00328            to be in a useful state: this depends entirely on the
00329            object (but, it could be argued, it it was in a useful
00330            state its deserialize operator would have returned true!).
00331 
00332        DO NOT PASS A POINTER TYPE TO THIS FUNCTION. It will not do
00333        what you want it to, and it will likely cause a leak. If
00334        you want to directly deserialize to a pointer, use the
00335        s11n::deserialize<>() overload which takes a reference to a
00336        pointer.
00337         */
00338         template <typename DeserializableT>
00339         bool deserialize( const node_type & src, DeserializableT & target )
00340         {
00341                 return instance().template deserialize<DeserializableT>( src, target );
00342         }
00343 
00344 
00345         /**
00346            Exactly like deserialize(), but operates on a subnode of
00347            src named subnodename. Returns false if no such file is
00348            found.
00349          */
00350         template <typename DeserializableT>
00351         bool deserialize_subnode( const node_type & src,
00352                                   const std::string & subnodename,
00353                                   DeserializableT & target )
00354         {
00355                 return instance().template deserialize_subnode<DeserializableT>( src, subnodename, target );
00356         }
00357 
00358         /**
00359            Exactly like deserialize(), but operates on a subnode of
00360            src named subnodename. Returns 0 if no such file is
00361            found.
00362          */
00363         template <typename DeserializableT>
00364         DeserializableT * deserialize_subnode( const node_type & src,
00365                                                const std::string & subnodename )
00366         {
00367                 return instance().template deserialize_subnode<DeserializableT>( src, subnodename );
00368         }
00369 
00370 
00371         /**
00372            Tries to load a data_node from src, then deserialize that
00373            to a SerializableType.
00374         */
00375         template <typename SerializableType>
00376         SerializableType * load_serializable( std::istream & src )
00377         {
00378         return instance().template load_serializable<SerializableType>( src );
00379         }
00380 
00381         /**
00382            Overloaded form which takes a file name.
00383 
00384        1.1.3: removed the never-used 2nd parameter.
00385         */
00386         template <typename SerializableType>
00387         SerializableType * load_serializable( const std::string & src )
00388         {
00389         return instance().template load_serializable<SerializableType>( src );
00390         }
00391 
00392         /**
00393            See s11n::s11n_clone().
00394 
00395        This function was renamed from clone() in version 1.1.
00396         */
00397         template <typename SerializableType>
00398         SerializableType * s11n_clone( const SerializableType & tocp )
00399         {
00400         return instance().template clone<SerializableType>( tocp );
00401         }
00402 
00403         /**
00404            See s11n::s11n_cast().
00405         */
00406         template <typename Type1, typename Type2>
00407         bool s11n_cast( const Type1 & t1, Type2 & t2 )
00408         {
00409         return instance().template cast<Type1,Type2>(t1,t2);
00410         }
00411 
00412 
00413 
00414     /**
00415        A binary functor to save s-nodes and Serializables
00416        using s11nlite::save().
00417 
00418        Added in version 1.1.3.
00419     */
00420     struct save_binary_f
00421     {
00422         typedef ::s11nlite::node_type node_type;
00423 
00424         /**
00425            Returns save(src,dest).
00426         */
00427         inline bool operator()( node_type const & src, std::string const & dest ) const
00428         {
00429             return ::s11nlite::save( src, dest );
00430         }
00431 
00432         /**
00433            Returns save(src,dest).
00434         */
00435         inline bool operator()( node_type const & src, std::ostream & dest ) const
00436         {
00437             return ::s11nlite::save( src, dest );
00438         }
00439 
00440         /**
00441            Returns save(src,dest).
00442         */
00443         template <typename SerT>
00444         inline bool operator()( SerT const & src, std::string const & dest ) const
00445         {
00446             return ::s11nlite::save( src, dest );
00447         }
00448 
00449         /**
00450            Returns save(src,dest).
00451         */
00452         template <typename SerT>
00453         inline bool operator()( SerT const & src, std::ostream  & dest ) const
00454         {
00455             return ::s11nlite::save( src, dest );
00456         }
00457 
00458 
00459     };
00460 
00461     /**
00462        A functor which forwards to s11nlite::save(node_type,string).
00463 
00464        See save_stream_unary_f for notes about the parent classes.
00465        Those same notes apply here.
00466 
00467        Added in version 1.1.3.
00468     */
00469     struct save_string_unary_f : ::s11n::serialize_unary_serializable_f_tag,
00470                      ::s11n::serialize_unary_node_f_tag
00471     {
00472         typedef ::s11nlite::node_type node_type;
00473         const std::string destination;
00474         /**
00475            Specifies that operator() should send output to the
00476            given resource name (normally, but not always, a
00477            filename).
00478         */
00479         explicit save_string_unary_f( std::string const & s ) : destination(s)
00480         {}
00481 
00482         /**
00483            Returns s11nlite:;save( src, this->destination ).
00484         */
00485         bool operator()( node_type const & src ) const
00486         {
00487             return ::s11nlite::save( src, this->destination );
00488         }
00489 
00490         /**
00491            Returns s11nlite:;save( src, this->destination ).
00492         */
00493         template <typename SerT>
00494         bool operator()( SerT const & src ) const
00495         {
00496             return ::s11nlite::save( src, this->destination );
00497         }
00498     };
00499 
00500 
00501     /**
00502        A unary functor which forwards to
00503        s11nlite::save(node_type|SerializableT,ostream).
00504 
00505        Note that while this type conforms to two s11n-standard
00506        tags (its parent classes), it is not *really* intended to
00507        be used as a normal part of a serialization algorithm. That
00508        said, that approach may indeed turn out to have some
00509        interesting uses. It certainly has some pitfalls, in any
00510        case, so don't blythely do it.
00511 
00512        Added in version 1.1.3.
00513     */
00514     struct save_stream_unary_f : ::s11n::serialize_unary_serializable_f_tag,
00515                      ::s11n::serialize_unary_node_f_tag
00516     {
00517         typedef ::s11nlite::node_type node_type;
00518         std::ostream & stream;
00519         /**
00520            Specifies that operator() should send output to the
00521            given stream.
00522         */
00523         explicit save_stream_unary_f( std::ostream & os ) : stream(os)
00524         {}
00525 
00526         /**
00527            Returns s11nlite:;save( src, this->stream ).
00528         */
00529         bool operator()( node_type const & src ) const
00530         {
00531             return ::s11nlite::save( src, this->stream );
00532         }
00533 
00534         /**
00535            Returns s11nlite:;save( src, this->stream ).
00536         */
00537         template <typename SerT>
00538         bool operator()( SerT const & src ) const
00539         {
00540             return ::s11nlite::save( src, this->stream );
00541         }
00542     };
00543 
00544 
00545     /**
00546        An "implementation detail" nullary functor type to simplify
00547        implementations of save_xxx_nullary_f. It is not intended
00548        for standalone use, but as a base type for
00549        save_xxx_nullary_f functors.
00550 
00551        T must be one of:
00552 
00553        - s11nlite::node_type
00554 
00555        - A non-cvp qualified Serializable type.
00556 
00557        OutputT is expected to be one of:
00558 
00559        - [const] std::string. NOT a reference, because we're
00560        lazily evaluating and don't want to step on a dead
00561        temporary.
00562 
00563        - (std::ostream &)
00564 
00565        If s11nlite::save() is ever overloaded, e.g., to take your
00566        own custom output destination type, then that type will
00567        also theoretically work here
00568 
00569        See save() for important notes about when you should NOT
00570        use this. In particular, this functor should not normally
00571        be used with std::for_each(), as save() expects to store
00572        ONE object in each target. Loading objects saved this way
00573        won't work: only the first one is likely to be read by
00574        load-time. Exceptions to this caveat include network
00575        streams or debug channels.
00576 
00577        Added in version 1.1.3.
00578 
00579     */
00580     template <typename T,typename OutputT>
00581     struct save_nullary_base_f
00582     {
00583         T const & source;
00584         OutputT destination;
00585         /**
00586            Both src and dest are expected to outlive this
00587            object, unless of source OutputT is a value type,
00588            in which case we copy dest at ctor time, instead of
00589            taking a (const &), to avoid us accidentally storing
00590            a reference to a temporary which probably won't
00591            exist when operator() is called.
00592         */
00593         save_nullary_base_f( T const & src, OutputT dest )
00594             : source(src), destination(dest)
00595         {}
00596         /**
00597            Returns ::s11nlite::save( this->source, this->destination ).
00598         */
00599         inline bool operator()() const
00600         {
00601             return ::s11nlite::save( this->source, this->destination );
00602         }
00603     };
00604 
00605     /**
00606        A nullary functor forwarding to s11nlite::save(node,string).
00607     */
00608     struct save_node_string_nullary_f : save_nullary_base_f< ::s11nlite::node_type, const std::string >
00609     {
00610         typedef save_nullary_base_f< ::s11nlite::node_type, const std::string > parent_t;
00611         typedef ::s11nlite::node_type node_type;
00612         /**
00613            See the notes in the base type API for requirements
00614            of src and dest.
00615         */
00616         save_node_string_nullary_f( node_type const & src, std::string const & dest )
00617             : parent_t( src, dest )
00618         {}
00619 
00620     };
00621 
00622     /**
00623        A nullary functor forwarding to s11nlite::save(node,string).
00624 
00625     */
00626     struct save_node_stream_nullary_f : save_nullary_base_f< ::s11nlite::node_type, std::ostream & >
00627     {
00628         typedef save_nullary_base_f< ::s11nlite::node_type, std::ostream & > parent_t;
00629         typedef ::s11nlite::node_type node_type;
00630         /**
00631            See the notes in the base type API for requirements
00632            of src and dest.
00633         */
00634         save_node_stream_nullary_f( node_type const & src, std::ostream & dest )
00635             : parent_t( src, dest )
00636         {}
00637     };
00638 
00639     /**
00640        A nullary functor forwarding to s11nlite::save(SerT,string).
00641     */
00642     template <typename SerT>
00643     struct save_serializable_string_nullary_f : save_nullary_base_f< SerT, const std::string >
00644     {
00645         typedef save_nullary_base_f< SerT, const std::string > parent_t;
00646         /**
00647            See the notes in the base type API for requirements
00648            of src and dest.
00649         */
00650         save_serializable_string_nullary_f( SerT const & src, std::string const & dest )
00651             : parent_t( src, dest )
00652         {}
00653     };
00654 
00655     /**
00656        A nullary functor forwarding to s11nlite::save(Serializable,ostream).
00657     */
00658     template <typename SerT>
00659     struct save_serializable_stream_nullary_f : save_nullary_base_f< SerT, std::ostream & >
00660     {
00661         /**
00662            See the notes in the base type API for requirements
00663            of src and dest.
00664         */
00665         typedef save_nullary_base_f< SerT, std::ostream & > parent_t;
00666         save_serializable_stream_nullary_f( SerT const & src, std::ostream & dest )
00667             : parent_t( src, dest )
00668         {}
00669     };
00670 
00671 
00672     /**
00673        Returns save_serializable_string_nullary_f<SerT>( src, dest ).
00674     */
00675     template <typename SerT>
00676     inline save_serializable_string_nullary_f<SerT>
00677     save_nullary_f( SerT const & src, std::string const & dest )
00678     {
00679         return save_serializable_string_nullary_f<SerT>( src, dest );
00680     }
00681 
00682     /**
00683        Returns save_serializable_stream_nullary_f<SerT>( src, dest ).
00684     */
00685     template <typename SerT>
00686     inline save_serializable_stream_nullary_f<SerT>
00687     save_nullary_f( SerT const & src, std::ostream & dest )
00688     {
00689         return save_serializable_stream_nullary_f<SerT>( src, dest );
00690     }
00691 
00692     /**
00693        Returns save_node_string_nullary_f( src, dest ).
00694     */
00695     inline save_node_string_nullary_f
00696     save_nullary_f( node_type const & src, std::string const & dest )
00697     {
00698         return save_node_string_nullary_f( src, dest );
00699     }
00700     /**
00701        Returns save_node_stream_nullary_f( src, dest ).
00702     */
00703     inline save_node_stream_nullary_f
00704     save_nullary_f( node_type const & src, std::ostream & dest )
00705     {
00706         return save_node_stream_nullary_f( src, dest );
00707     }
00708 
00709 
00710 
00711 
00712     /**
00713        A nullary functor to call s11nlite::load_node(istream&).
00714 
00715        Added in version 1.1.3.
00716     */
00717     struct load_node_stream_nullary_f
00718     {
00719         std::istream & stream;
00720         typedef ::s11nlite::node_type node_type;
00721         /**
00722            Specifies that operator() should fetch input from the
00723            given stream.
00724         */
00725         explicit load_node_stream_nullary_f( std::istream & s ) : stream(s)
00726         {}
00727 
00728         /**
00729            Returns s11nlite::load_node( this->stream ),
00730 
00731            Caller owns the returned object, which may be 0.
00732         */
00733         inline node_type * operator()() const
00734         {
00735             return ::s11nlite::load_node( this->stream );
00736         }
00737     };
00738 
00739     /**
00740        A nullary functor to call s11nlite::load_node(string).
00741     */
00742     struct load_node_nullary_string_f
00743     {
00744         typedef ::s11nlite::node_type node_type;
00745         const std::string resource;
00746         /**
00747            Specifies that operator() should fetch input from
00748            the given resource name (normally, but not always,
00749            a filename).
00750         */
00751         explicit load_node_nullary_string_f( std::string const & s ) : resource(s)
00752         {}
00753 
00754         /**
00755            Returns s11nlite::load_node( this->resource ).
00756 
00757            Caller owns the returned object, which may be 0.
00758         */
00759         inline node_type * operator()() const
00760         {
00761             return ::s11nlite::load_node( this->resource );
00762         }
00763     };
00764 
00765 
00766     /**
00767        Returns load_node_nullary_string_f(s).
00768     */
00769     inline load_node_nullary_string_f
00770     load_node_nullary_f( std::string const & s )
00771     {
00772         return load_node_nullary_string_f(s);
00773     }
00774 
00775     /**
00776        Returns load_node_stream_nullary_f(s).
00777     */
00778     inline load_node_stream_nullary_f
00779     load_node_nullary_f( std::istream & s )
00780     {
00781         return load_node_stream_nullary_f(s);
00782     }
00783     
00784 
00785     /**
00786        A unary functor to call s11nlite::load_node(string|stream).
00787     */
00788     struct load_node_unary_f
00789     {
00790 
00791         /**
00792            Returns s11nlite::load_node( src ).
00793         */
00794         inline bool operator()( std::string const & src ) const
00795         {
00796             return ::s11nlite::load_node( src );
00797         }
00798 
00799         /**
00800            Returns s11nlite::load_node( src ).
00801         */
00802         inline bool operator()( std::istream & src ) const
00803         {
00804             return ::s11nlite::load_node( src );
00805         }
00806     };
00807 
00808 
00809 } // namespace s11nlite
00810 
00811 #endif // S11N_LITE_H_INCLUDED

Generated on Sun Apr 27 11:48:19 2008 for libs11n-1.2.6 by  doxygen 1.5.3