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 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         template <typename DeserializableT>
00333         bool deserialize( const node_type & src, DeserializableT & target )
00334         {
00335                 return instance().template deserialize<DeserializableT>( src, target );
00336         }
00337 
00338 
00339         /**
00340            Exactly like deserialize(), but operates on a subnode of
00341            src named subnodename. Returns false if no such file is
00342            found.
00343          */
00344         template <typename DeserializableT>
00345         bool deserialize_subnode( const node_type & src,
00346                                   const std::string & subnodename,
00347                                   DeserializableT & target )
00348         {
00349                 return instance().template deserialize_subnode<DeserializableT>( src, subnodename, target );
00350         }
00351 
00352         /**
00353            Exactly like deserialize(), but operates on a subnode of
00354            src named subnodename. Returns 0 if no such file is
00355            found.
00356          */
00357         template <typename DeserializableT>
00358         DeserializableT * deserialize_subnode( const node_type & src,
00359                                                const std::string & subnodename )
00360         {
00361                 return instance().template deserialize_subnode<DeserializableT>( src, subnodename );
00362         }
00363 
00364 
00365         /**
00366            Tries to load a data_node from src, then deserialize that
00367            to a SerializableType.
00368         */
00369         template <typename SerializableType>
00370         SerializableType * load_serializable( std::istream & src )
00371         {
00372         return instance().template load_serializable<SerializableType>( src );
00373         }
00374 
00375         /**
00376            Overloaded form which takes a file name.
00377 
00378        1.1.3: removed the never-used 2nd parameter.
00379         */
00380         template <typename SerializableType>
00381         SerializableType * load_serializable( const std::string & src )
00382         {
00383         return instance().template load_serializable<SerializableType>( src );
00384         }
00385 
00386         /**
00387            See s11n::s11n_clone().
00388 
00389        This function was renamed from clone() in version 1.1.
00390         */
00391         template <typename SerializableType>
00392         SerializableType * s11n_clone( const SerializableType & tocp )
00393         {
00394         return instance().template clone<SerializableType>( tocp );
00395         }
00396 
00397         /**
00398            See s11n::s11n_cast().
00399         */
00400         template <typename Type1, typename Type2>
00401         bool s11n_cast( const Type1 & t1, Type2 & t2 )
00402         {
00403         return instance().template cast<Type1,Type2>(t1,t2);
00404         }
00405 
00406 
00407 
00408     /**
00409        A binary functor to save s-nodes and Serializables
00410        using s11nlite::save().
00411 
00412        Added in version 1.1.3.
00413     */
00414     struct save_binary_f
00415     {
00416         typedef ::s11nlite::node_type node_type;
00417 
00418         /**
00419            Returns save(src,dest).
00420         */
00421         inline bool operator()( node_type const & src, std::string const & dest ) const
00422         {
00423             return ::s11nlite::save( src, dest );
00424         }
00425 
00426         /**
00427            Returns save(src,dest).
00428         */
00429         inline bool operator()( node_type const & src, std::ostream & dest ) const
00430         {
00431             return ::s11nlite::save( src, dest );
00432         }
00433 
00434         /**
00435            Returns save(src,dest).
00436         */
00437         template <typename SerT>
00438         inline bool operator()( SerT const & src, std::string const & dest ) const
00439         {
00440             return ::s11nlite::save( src, dest );
00441         }
00442 
00443         /**
00444            Returns save(src,dest).
00445         */
00446         template <typename SerT>
00447         inline bool operator()( SerT const & src, std::ostream  & dest ) const
00448         {
00449             return ::s11nlite::save( src, dest );
00450         }
00451 
00452 
00453     };
00454 
00455     /**
00456        A functor which forwards to s11nlite::save(node_type,string).
00457 
00458        See save_stream_unary_f for notes about the parent classes.
00459        Those same notes apply here.
00460 
00461        Added in version 1.1.3.
00462     */
00463     struct save_string_unary_f : ::s11n::serialize_unary_serializable_f_tag,
00464                      ::s11n::serialize_unary_node_f_tag
00465     {
00466         typedef ::s11nlite::node_type node_type;
00467         const std::string destination;
00468         /**
00469            Specifies that operator() should send output to the
00470            given resource name (normally, but not always, a
00471            filename).
00472         */
00473         explicit save_string_unary_f( std::string const & s ) : destination(s)
00474         {}
00475 
00476         /**
00477            Returns s11nlite:;save( src, this->destination ).
00478         */
00479         bool operator()( node_type const & src ) const
00480         {
00481             return ::s11nlite::save( src, this->destination );
00482         }
00483 
00484         /**
00485            Returns s11nlite:;save( src, this->destination ).
00486         */
00487         template <typename SerT>
00488         bool operator()( SerT const & src ) const
00489         {
00490             return ::s11nlite::save( src, this->destination );
00491         }
00492     };
00493 
00494 
00495     /**
00496        A unary functor which forwards to
00497        s11nlite::save(node_type|SerializableT,ostream).
00498 
00499        Note that while this type conforms to two s11n-standard
00500        tags (its parent classes), it is not *really* intended to
00501        be used as a normal part of a serialization algorithm. That
00502        said, that approach may indeed turn out to have some
00503        interesting uses. It certainly has some pitfalls, in any
00504        case, so don't blythely do it.
00505 
00506        Added in version 1.1.3.
00507     */
00508     struct save_stream_unary_f : ::s11n::serialize_unary_serializable_f_tag,
00509                      ::s11n::serialize_unary_node_f_tag
00510     {
00511         typedef ::s11nlite::node_type node_type;
00512         std::ostream & stream;
00513         /**
00514            Specifies that operator() should send output to the
00515            given stream.
00516         */
00517         explicit save_stream_unary_f( std::ostream & os ) : stream(os)
00518         {}
00519 
00520         /**
00521            Returns s11nlite:;save( src, this->stream ).
00522         */
00523         bool operator()( node_type const & src ) const
00524         {
00525             return ::s11nlite::save( src, this->stream );
00526         }
00527 
00528         /**
00529            Returns s11nlite:;save( src, this->stream ).
00530         */
00531         template <typename SerT>
00532         bool operator()( SerT const & src ) const
00533         {
00534             return ::s11nlite::save( src, this->stream );
00535         }
00536     };
00537 
00538 
00539     /**
00540        An "implementation detail" nullary functor type to simplify
00541        implementations of save_xxx_nullary_f. It is not intended
00542        for standalone use, but as a base type for
00543        save_xxx_nullary_f functors.
00544 
00545        T must be one of:
00546 
00547        - A non-cvp (const/volatile/pointer) qualified
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 Dec 10 13:38:25 2005 for libs11n-1.2.1 by  doxygen 1.4.4