parseobj.hpp

Go to the documentation of this file.

// See ../../license.txt for license information.
//
// parseobj.hpp
//
// NOTES
//              XML Parser for the persistence framework.
//
// 30-Jun-2003  phamilton  Created
//

#ifndef incPERSIST_XML_PARSEOBJ
#define incPERSIST_XML_PARSEOBJ

// forwards
#include <string>
#include <stack>
#include <vector>
#include <map>
#include "parse.hpp"
#include "parseobj_opts.h"
#include "boost/filesystem/path.hpp"

namespace ph {
namespace common {
class object_base;
class persistable_object_context;
class importable_object_base;
};
namespace persist {
namespace xml {

class PERSIST_DECL parseobj : public parse
/*
        Concrete subclass for xml::parse for parseing objects.
*/
{
public:
        parseobj(parseobj *outer, // the outer parser (they are nested).
                std::istream *stream, // the stream we are parseing from.
                const boost::filesystem::path &streampath, // the pathname for the above stream.
                ph::common::persistable_object_context *context, // a context to pass around.
                std::ostream *console, // where to write messages.
                const boost::filesystem::path &rootpath, // the basepath for the parse.
                bool silent, // write errors out?
                unsigned int debug=PARSEOBJ_NO_DEBUG);

                ph::common::object_base *obj() { return _obj; };
                        //!< return the object that was parsed.
                        
                void add_params(const std::map<std::string, std::string> &params);
                        //!< add the map of parameters passed in to this parser.
                        
                void set_root_outer(ph::common::object_base *outer) 
                        { _rootouter = outer; }
                        //!< set an outer object to use for the root object.
private:
        parseobj            *_outer; // the "outer" parser for importing.
        std::istream        *_stream; // where we are reading from.
        boost::filesystem::path _streampath; // the name of the above.
        ph::common::persistable_object_context      *_context; 
                        // the context is used to communicate with teh base system.
        boost::filesystem::path  _rootpath; // TBD: Not implemented yet.
        ph::common::object_base *_obj; // the object to return from the parse.
        ph::common::object_base *_root; // the root object in the system.
        ph::common::object_base *_rootouter; // the outer object for the root in the system.
        std::string          _cdata; // the latest cdata that we have accumulated
        std::string          _comment; // TBD: Not implemented yet.
        bool                 _abort; // we should abort.
        bool                 _inmember;
        int                  _anonymousobjnum;
        unsigned int         _debug;
        std::stack<ph::common::object_base *> _stack;
        
        // importing.
        parseobj                *_import; // the parser to use for the import.
        std::istream            *_importstream; // the stream to use for the import.
        boost::filesystem::path  _importstreampath; // the aboves path (on the disk).
        std::string              _rootname; // name we should give to the root object.
        std::map<std::string, std::string> _params; // parameters used during import.
        ph::common::importable_object_base *_delayed_obj; // we are in the middle of a delayed import.
        
        // fragments
        bool                     _fragment; // we are inside a fragment.

        ph::common::object_base *create_object(ph::common::object_base *top,
                const xmlstring &type, const xmlstring &name);
        xmlstring dosubs(const xmlstring &s);
        xmlstring getdecodedattrval(const std::vector<xmlstring> &atts, int index);
        xmlstring getdecodedexpectedattr(const std::vector<xmlstring> &atts, 
                const xmlstring &token);
        xmlstring getdecodedattr(const std::vector<xmlstring> &atts, const xmlstring &token);
        void add_param(const std::string &name, const std::string &val);
        static void add_param_1(std::map<std::string, std::string> *params, 
                const std::string &name, const std::string &val);
        bool find_param(const std::string &name, std::string *value);
        bool test_outerable(ph::common::object_base *obj);
        bool test_persistable(ph::common::object_base *obj);
        bool test_composition(ph::common::object_base *obj);

        // parse
        virtual void startelement_handler(const xmlstring &name, 
                const std::vector<xmlstring> &atts);
        virtual void endelement_handler(const xmlstring &name);
        virtual void cdata_handler(const xmlstring &s, int len);
        virtual void comment_handler(const xmlstring &s);
        virtual void finish_handler();
        
        // debugging.
        void obj_out(const std::string &msg, ph::common::object_base *obj);
        void element_out(const std::string &msg, const xmlstring &element);
};

}; // xml
}; // persist
}; // ph

#endif // incPERSIST_XML_PARSEOBJ

---