Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

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

Generated on Thu Sep 29 20:01:14 2005 for libs11n-1.1.3-dev by  doxygen 1.4.1