xml_config.hpp

#ifndef HAVE_TOM__XML_CONFIG_HPP
#define HAVE_TOM__XML_CONFIG_HPP
 
#include <tom-util/defines.hpp>
#include <tom-util/scalar.hpp>
#include <libxml/xpath.h>
#include <libxml/parser.h>
#include <vector>
#include <map>
#include <boost/shared_ptr.hpp>
 
namespace tom {
    
class xml_doc_factory;
class xml_node;
class xml_doc;
 
typedef std::vector< xml_node >     xml_node_set;
typedef xml_node_set::const_iterator xml_node_set_it;
 
class TOM_UTIL_API xml_doc_factory
{
    public:
        static xml_doc doc_from_file( const char * path );
        static xml_doc doc_from_file( const tom::observation & path );
        
        // call to clean up libxml2 resources...this is called when the environment
        // goes out of scope so users can ignore this
        static void finalize( );
    protected:
        static void init( );
        static bool s_is_init;
};
 
class TOM_UTIL_API xml_doc
{
public:
    class xmlDocPtrHandle
    {
    public:
        explicit xmlDocPtrHandle( xmlDocPtr doc ) : m_doc( doc ) { }
        xmlDocPtr
        doc( ) const { return m_doc; }
        ~xmlDocPtrHandle ( ) { xmlFreeDoc( m_doc ); }   
 
    private:
        xmlDocPtrHandle( );
        xmlDocPtrHandle( const xmlDocPtrHandle & );
        xmlDocPtrHandle &
        operator=( const xmlDocPtrHandle & );
        
        xmlDocPtr m_doc;
    };
    
    xml_doc( ) : m_xmlDocPtr(), m_namespaces_init(false) { }
    xml_doc( xmlDocPtr doc ) : m_xmlDocPtr( new xmlDocPtrHandle(doc) ), m_namespaces_init(false)  { }
    virtual ~xml_doc( );
 
    xml_doc( const xml_doc &rhs ) : m_xmlDocPtr( rhs.m_xmlDocPtr ), m_namespaces_init(false) { }
    xml_doc &
    operator=( const xml_doc &rhs )
    {
        m_xmlDocPtr = rhs.m_xmlDocPtr;
        m_namespaces_init = false;
        return *this;
    }
    
    void doc_to_file(const char * path, bool formatted=false);
    bool valid() const { return m_xmlDocPtr == NULL ? false : true; }
    xml_node get_root_node() const;
    // add a new text node in "xpath"
    xml_node add_node(const char *xpath, const char* ns_prefix, const char* name, 
                    const char* content);
    // add a new text node in "root"
    xml_node add_node(const char* ns_prefix, const char* name, const char* content);
    xml_node_set exec_xpath( const char *xpath );
    xml_node_set exec_xpath( const observation &xpath );
    
protected:
    typedef std::map<const xmlChar *, const xmlChar *>  namespace_map_t;
    namespace_map_t &get_namespaces();
    void register_namespaces( xmlXPathContextPtr ctx );
    void collect_namespaces( xmlNodePtr node );
 
    namespace_map_t m_namespaces;
    boost::shared_ptr<xmlDocPtrHandle> m_xmlDocPtr;
    bool m_namespaces_init;
};
 
class TOM_UTIL_API xml_node
{
public:
    xml_node() : m_node( 0 ), m_doc(0 ) { }
    xml_node( xmlNodePtr node, xmlDocPtr doc) : m_node( node ), m_doc( doc ) { }
    xml_node(const xml_node& node) : m_node(node.m_node), m_doc(node.m_doc) { }
    xml_node& operator=(const xml_node& doc);
    
    virtual ~xml_node() { }
    
    bool valid( ) const { return m_node == NULL ? false : true; }
  xml_node add_node(const char* ns_prefix, const char* name, const char* content);
  void add_attribute(const char* ns_prefix, const char* name, const char* value);
  void set_attribute(const char* ns_prefix, const char* name, const char* value);
  xml_node_set get_sub_nodes( ) const;
 
    tom::String get_name( ) const;
  void set_content( const char *content );
  tom::String get_content( const char *sub_node ) const;
    tom::String get_content( ) const;
    tom::String get_attribute( const observation & att_name ) const;
    tom::String get_attribute( const char * att_name ) const;
 
protected:
    xmlNodePtr m_node;
    xmlDocPtr m_doc;
};
 
//TOM_NAMESPACE_END;
} // end tom namespace
 
#endif