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

Generated on Sun Dec 18 18:30:27 2005 for libs11n-1.2.2 by  doxygen 1.4.4