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

Generated on Sat Mar 20 12:29:24 2010 for libs11n-1.2.10 by  doxygen 1.6.1