XMLNode.h

// -*- indent-tabs-mode: nil -*-

#ifndef __ARC_XMLNODE_H__
#define __ARC_XMLNODE_H__

#include <iostream>
#include <string>
#include <list>
#include <vector>
#include <map>

#include <libxml/xmlmemory.h>
#include <libxml/tree.h>
#include <libxml/parser.h>
#include <libxml/xpath.h>
#include <libxml/xpathInternals.h>
#include <libxml/xmlschemas.h>

namespace Arc {

  class XMLNode;


  class NS
    : public std::map<std::string, std::string> {
  public:
    NS(void) {}
    NS(const char *prefix, const char *uri) {
      operator[](prefix) = uri;
    }

    NS(const char *nslist[][2]) {
      for (int n = 0; nslist[n][0]; ++n)
        operator[](nslist[n][0]) = nslist[n][1];
    }
    NS(const std::map<std::string, std::string>& nslist)
      : std::map<std::string, std::string>(nslist) {}
  };

  typedef std::list<XMLNode> XMLNodeList;


  class XMLNode {
    friend bool MatchXMLName(const XMLNode& node1, const XMLNode& node2);
    friend bool MatchXMLName(const XMLNode& node, const char *name);
    friend bool MatchXMLName(const XMLNode& node, const std::string& name);
    friend bool MatchXMLNamespace(const XMLNode& node1, const XMLNode& node2);
    friend bool MatchXMLNamespace(const XMLNode& node, const char *uri);
    friend bool MatchXMLNamespace(const XMLNode& node, const std::string& uri);
    friend class XMLNodeContainer;

  protected:
    xmlNodePtr node_;

    bool is_owner_;
    bool is_temporary_;

    XMLNode(xmlNodePtr node)
      : node_(node),
        is_owner_(false),
        is_temporary_(false) {}

    static void LogError(void * ctx, const char * msg, ...);

    bool Validate(xmlSchemaPtr schema, std::string &err_msg);

  public:

    XMLNode(void)
      : node_(NULL),
        is_owner_(false),
        is_temporary_(false) {}

    XMLNode(const XMLNode& node)
      : node_(node.node_),
        is_owner_(false),
        is_temporary_(false) {}

    XMLNode(const std::string& xml);

    XMLNode(const char *xml, int len = -1);
    XMLNode(long ptr_addr);

    XMLNode(const NS& ns, const char *name);

    ~XMLNode(void);

    void New(XMLNode& node) const;

    void Exchange(XMLNode& node);

    void Move(XMLNode& node);

    void Swap(XMLNode& node);
    operator bool(void) const {
      return ((node_ != NULL) && (!is_temporary_));
    }
    bool operator!(void) const {
      return ((node_ == NULL) || is_temporary_);
    }
    bool operator==(const XMLNode& node) {
      return ((node_ == node.node_) && (node_ != NULL));
    }
    bool operator!=(const XMLNode& node) {
      return ((node_ != node.node_) || (node_ == NULL));
    }
    bool Same(const XMLNode& node) {
      return operator==(node);
    }
    bool operator==(bool val) {
      return ((bool)(*this) == val);
    }
    bool operator!=(bool val) {
      return ((bool)(*this) != val);
    }
    bool operator==(const std::string& str) {
      return ((std::string)(*this) == str);
    }
    bool operator!=(const std::string& str) {
      return ((std::string)(*this) != str);
    }
    bool operator==(const char *str) {
      return ((std::string)(*this) == str);
    }
    bool operator!=(const char *str) {
      return ((std::string)(*this) != str);
    }

    XMLNode Child(int n = 0);

    XMLNode operator[](const char *name) const;

    XMLNode operator[](const std::string& name) const {
      return operator[](name.c_str());
    }

    XMLNode operator[](int n) const;

    void operator++(void);

    void operator--(void);
    int Size(void) const;
    XMLNode Get(const std::string& name) const {
      return operator[](name.c_str());
    }
    std::string Name(void) const;
    std::string Prefix(void) const;
    std::string FullName(void) const {
      return Prefix() + ":" + Name();
    }
    std::string Namespace(void) const;

    void Prefix(const std::string& prefix, int recursion = 0);
    void StripNamespace(int recursion = 0);
    void Name(const char *name);
    void Name(const std::string& name) {
      Name(name.c_str());
    }
    void GetXML(std::string& out_xml_str, bool user_friendly = false) const;

    void GetXML(std::string& out_xml_str, const std::string& encoding, bool user_friendly = false) const;
    void GetDoc(std::string& out_xml_str, bool user_friendly = false) const;
    operator std::string(void) const;
    XMLNode& operator=(const char *content);
    XMLNode& operator=(const std::string& content) {
      return operator=(content.c_str());
    }
    void Set(const std::string& content) {
      operator=(content.c_str());
    }

    XMLNode& operator=(const XMLNode& node);
    // Returns list of all attributes of node
    // std::list<XMLNode> Attributes(void);
    XMLNode Attribute(int n = 0);
    XMLNode Attribute(const char *name);
    XMLNode Attribute(const std::string& name) {
      return Attribute(name.c_str());
    }
    XMLNode NewAttribute(const char *name);
    XMLNode NewAttribute(const std::string& name) {
      return NewAttribute(name.c_str());
    }
    int AttributesSize(void) const;

    void Namespaces(const NS& namespaces, bool keep = false, int recursion = -1);
    NS Namespaces(void);
    std::string NamespacePrefix(const char *urn);

    XMLNode NewChild(const char *name, int n = -1, bool global_order = false);
    XMLNode NewChild(const std::string& name, int n = -1, bool global_order = false) {
      return NewChild(name.c_str(), n, global_order);
    }

    XMLNode NewChild(const char *name, const NS& namespaces, int n = -1, bool global_order = false);
    XMLNode NewChild(const std::string& name, const NS& namespaces, int n = -1, bool global_order = false) {
      return NewChild(name.c_str(), namespaces, n, global_order);
    }

    XMLNode NewChild(const XMLNode& node, int n = -1, bool global_order = false);
    void Replace(const XMLNode& node);

    void Destroy(void);

    XMLNodeList Path(const std::string& path);

    XMLNodeList XPathLookup(const std::string& xpathExpr, const NS& nsList);
    XMLNode GetRoot(void);
    XMLNode Parent(void);
    bool SaveToFile(const std::string& file_name) const;
    bool SaveToStream(std::ostream& out) const;
    bool ReadFromFile(const std::string& file_name);
    bool ReadFromStream(std::istream& in);
    // Remove all eye-candy information leaving only informational parts
    //   void Purify(void);.
    bool Validate(const std::string &schema_file, std::string &err_msg);
    bool Validate(XMLNode schema_doc, std::string &err_msg);
  };

  std::ostream& operator<<(std::ostream& out, const XMLNode& node);
  std::istream& operator>>(std::istream& in, XMLNode& node);


  class XMLNodeContainer {
  private:
    std::vector<XMLNode*> nodes_;
  public:
    XMLNodeContainer(void);

    XMLNodeContainer(const XMLNodeContainer&);
    ~XMLNodeContainer(void);
    XMLNodeContainer& operator=(const XMLNodeContainer&);

    void Add(const XMLNode&);
    void Add(const std::list<XMLNode>&);

    void AddNew(const XMLNode&);
    void AddNew(const std::list<XMLNode>&);
    int Size(void) const;
    XMLNode operator[](int);
    std::list<XMLNode> Nodes(void);
  };

  bool MatchXMLName(const XMLNode& node1, const XMLNode& node2);

  bool MatchXMLName(const XMLNode& node, const char *name);

  bool MatchXMLName(const XMLNode& node, const std::string& name);

  bool MatchXMLNamespace(const XMLNode& node1, const XMLNode& node2);

  bool MatchXMLNamespace(const XMLNode& node, const char *uri);

  bool MatchXMLNamespace(const XMLNode& node, const std::string& uri);

} // namespace Arc

#endif /* __ARC_XMLNODE_H__ */