xml.h

/*
 *  Copyright (c) 2003-2007    National Research Council
 *
 *  All rights reserved.
 *
 *  This material is confidential and proprietary information of
 *  National Research Council Canada ("Confidential Information").
 *  This Confidential Information may only be used and reproduced
 *  in accordance with the terms of the license agreement.
 *
 */

#ifndef __INLUCDED__SCOPIRA_TOOL_XML_H_
#define __INLUCDED__SCOPIRA_TOOL_XML_H_

#include <libxml/parser.h>

#include <string>

#include <scopira/tool/object.h>
#include <scopira/tool/export.h>

// THIS FILE HAS BEEN FULLY DOCUMENTED

namespace scopira
{
  namespace tool
  {
    class xml_doc;
    class xml_node;
    class xml_attrib;
    // forward
    class property;
  }
}

//
// TIPS:
//  use xmllint.
//  or xmlstarlet val
//

class scopira::tool::xml_doc : public scopira::tool::object
{
  private:
    xmlDocPtr dm_doc;

  public:

    xml_doc(void) : dm_doc(0) { }
    ~xml_doc() { clear(); }

    xmlDocPtr get_ptr(void) const { return dm_doc; }

    bool is_null(void) const { return dm_doc == 0; }
    bool is_valid(void) const { return dm_doc != 0; }

    const char * get_c_name(void) const { return dm_doc->name; }
    std::string get_name(void) const
      { return std::string(reinterpret_cast<const char*>(dm_doc->name)); }

    SCOPIRA_EXPORT void clear(void);

    SCOPIRA_EXPORT void init(const std::string &rootnodename);

    SCOPIRA_EXPORT void add_pi(const std::string &name, const std::string &content = "");

    SCOPIRA_EXPORT void load_ptr(xmlDocPtr newdoc);

    SCOPIRA_EXPORT bool load_file(const std::string &filename);

    SCOPIRA_EXPORT bool load_string(const std::string &data);

    SCOPIRA_EXPORT bool load_c_str(const char *str);

    SCOPIRA_EXPORT void load_prop(property *p);

    SCOPIRA_EXPORT xml_node get_root(void) const;

    SCOPIRA_EXPORT bool save_file(const std::string &filename, bool compress = false) const;

    SCOPIRA_EXPORT bool save_string(std::string &out) const;

    SCOPIRA_EXPORT void save_prop(property *p) const;

  private:
    // diable
    xml_doc(const xml_doc &) { }
};

class scopira::tool::xml_node
{
  public:
    enum {
      element_c = XML_ELEMENT_NODE,
      //attrib_c = XML_ATTRIBUTE_NODE,
      text_c = XML_TEXT_NODE,
    };

  private:
    xmlNodePtr dm_node;

  public:
    xml_node(void) : dm_node(0) { }
    explicit xml_node(xmlNodePtr ptr) : dm_node(ptr) { }

    xmlNodePtr get_ptr(void) const { return dm_node; }

    int get_type(void) const { return dm_node->type; }

    const char * get_c_name(void) const
      { return reinterpret_cast<const char*>(dm_node->name); }
    std::string get_name(void) const
      { return std::string(reinterpret_cast<const char*>(dm_node->name)); }

    const char * get_c_content(void) const
      { return reinterpret_cast<const char *>(dm_node->content); }

    bool is_null(void) const { return dm_node == 0; }
    bool is_valid(void) const { return dm_node != 0; }

    void next(void) { dm_node = dm_node->next; }
    SCOPIRA_EXPORT void next_type(int typ);
    SCOPIRA_EXPORT void next_name(const std::string &name);

    SCOPIRA_EXPORT int count_children(const std::string &name) const;

    xml_node get_first_child(void) const
      { return xml_node(dm_node->children); }
    SCOPIRA_EXPORT xml_node get_first_child_type(int typ) const;
    SCOPIRA_EXPORT xml_node get_first_child_name(const std::string &name) const;

    SCOPIRA_EXPORT xml_attrib get_first_attrib(void) const;
    SCOPIRA_EXPORT const char * get_attrib_c_text(const std::string &aname) const;
    SCOPIRA_EXPORT const char * get_child_c_text(const std::string &nname) const;

    SCOPIRA_EXPORT bool has_attrib(const std::string &aname) const;

    SCOPIRA_EXPORT xml_node add_child(const std::string &name);

    SCOPIRA_EXPORT xml_node add_comment(const std::string &comment_contents);

    SCOPIRA_EXPORT void clear_this(void);
    SCOPIRA_EXPORT void add_attrib(const std::string &key, const std::string &val);
    SCOPIRA_EXPORT xml_node add_content_child(const std::string &content);
    SCOPIRA_EXPORT void clear_content_children(void);

    SCOPIRA_EXPORT const char * get_text_c_content(void) const;
    
    SCOPIRA_EXPORT const char * get_leaf_text_content(const std::string &pathnodespec) const;
    
    // Mass loader helpers

    SCOPIRA_EXPORT void load_string_attrib(const std::string &name, std::string &outval);
    template <class I>
      void children_load_xml(const std::string &elementname, I iter) const {
        for (xml_node sub = get_first_child_name(elementname);
            sub.is_valid(); sub.next_name(elementname), ++iter)
          (*iter).load_xml(sub);
      }
    template <class I>
      void children_load_attrib(const std::string &elementname,
          const std::string &attribname, I iter) const {
        for (xml_node sub = get_first_child_name(elementname);
            sub.is_valid(); sub.next_name(elementname), ++iter)
          sub.load_string_attrib(attribname, *iter);
      }
    template <class I>
      void children_load_text(const std::string &elementname, I iter) const {
        for (xml_node sub = get_first_child_name(elementname);
            sub.is_valid(); sub.next_name(elementname), ++iter)
          *iter = sub.get_text_c_content();
      }
};

class scopira::tool::xml_attrib
{
  private:
    xmlAttrPtr dm_attr;

  public:
    xml_attrib(void) : dm_attr(0) { }
    xml_attrib(xmlAttrPtr ptr) : dm_attr(ptr) { }

    xmlAttrPtr get_ptr(void) const { return dm_attr; }

    const char * get_c_name(void) const
      { return reinterpret_cast<const char*>(dm_attr->name); }
    std::string get_name(void) const
      { return std::string(reinterpret_cast<const char*>(dm_attr->name)); }

    bool is_null(void) const { return dm_attr == 0; }
    bool is_valid(void) const { return dm_attr != 0; }

    void next(void) { dm_attr = dm_attr->next; }

    SCOPIRA_EXPORT const char * get_text_c_content(void) const;
};

#endif