Node.hpp

Go to the documentation of this file.

// ANNA - Anna is Not Nothingness Anymore                                                         //
//                                                                                                //
// (c) Copyright 2005-2015 Eduardo Ramos Testillano & Francisco Ruiz Rayo                         //
//                                                                                                //
// See project site at http://redmine.teslayout.com/projects/anna-suite                           //
// See accompanying file LICENSE or copy at http://www.teslayout.com/projects/public/anna.LICENSE //


#ifndef anna_xml_Node_hpp
#define anna_xml_Node_hpp

#include <vector>

#include <anna/core/Allocator.hpp>
#include <anna/core/RuntimeException.hpp>
#include <anna/core/functions.hpp>
#include <anna/core/util/Recycler.hpp>
#include <anna/core/util/SortedVector.hpp>

#include <anna/xml/Namespace.hpp>

namespace anna {

namespace xml {

class Parser;
class Attribute;
class Text;
class XPath;
class Decompressor;

class Node {
  struct NamespaceByName {
    static const std::string& value(const Namespace* ns) { return ns->getName(); }
  };

public:
  typedef std::vector <Node*> Children; 
  typedef Children::iterator child_iterator; 
  typedef Children::const_iterator const_child_iterator; 
  typedef std::vector <Attribute*> Attributes; 
  typedef Attributes::iterator attribute_iterator; 
  typedef Attributes::const_iterator const_attribute_iterator; 
  typedef SortedVector <Namespace, NamespaceByName, std::string> namespace_container;
  typedef namespace_container::iterator namespace_iterator;
  typedef namespace_container::const_iterator const_namespace_iterator;

  Node(const char* name);

  virtual ~Node();

  const char* getName() const { return a_name.c_str(); }

  const std::string& getNameAsString() const { return a_name; }

  const Node* getParent() const { return a_parent; }

  Node* getParent() { return const_cast <Node*>(a_parent); }

  const Attribute* getAttribute(const char* name, const bool exceptionWhenNotFound = true) const noexcept(false);

  const Text* getText() const { return a_text; }

  const Namespace* getNamespace() const { return a_namespace; }

  child_iterator child_begin() { return a_children.begin(); }

  const_child_iterator child_begin() const { return a_children.begin(); }

  const_attribute_iterator attribute_begin() const { return a_attributes.begin(); }

  const_namespace_iterator namespace_begin() const { return a_root->a_namespaces->begin(); }


  child_iterator child_end() { return a_children.end(); }

  const_child_iterator child_end() const { return a_children.end(); }

  int child_size() const { return a_children.size(); }

  const_attribute_iterator attribute_end() const { return a_attributes.end(); }

  const_namespace_iterator namespace_end() const { return a_root->a_namespaces->end(); }

  int namespace_size() const { return a_root->a_namespaces->size(); }

  const Node* find(const char* childName, const bool exceptionWhenNotFound = true) const
  noexcept(false);

  xml::Attribute* createAttribute(const char* name, const char* value, const Namespace* _namespace = NULL) ;

  xml::Attribute* createAttribute(const char* name, const std::string& value, const Namespace* _namespace = NULL) {
    return createAttribute(name, value.c_str(), _namespace);
  }

  xml::Attribute* createAttribute(const char* name, const int value, const Namespace* _namespace = NULL) {
    return createAttribute(name, anna::functions::asString(value), _namespace);
  }

  xml::Attribute* createAttribute(const char* name, const S64* value, const Namespace* _namespace = NULL) {
    return createAttribute(name, anna::functions::asString(*value), _namespace);
  }

  xml::Attribute* createAttribute(const char* name, const U64* value, const Namespace* _namespace = NULL) {
    return createAttribute(name, anna::functions::asString(*value), _namespace);
  }

  xml::Text* createText(const char* text) noexcept(false);

  xml::Text* createText(const std::string& text) noexcept(false) { return createText(text.c_str()); }

  Node* createChild(const char* name) ;

  const Namespace* createNamespace(const char* name, const char* reference) noexcept(false) {
    std::string _name(name);
    return createNamespace(_name, reference);
  }

  const Namespace* createNamespace(const std::string& name, const char* reference) noexcept(false);

  void setNamespace(const Namespace* _namespace) { a_namespace = _namespace; }

  Namespace* namespace_find(const char* name,  const bool exceptionWhenNotFound = true) noexcept(false) {
    const std::string _name(name);
    return namespace_find(_name, exceptionWhenNotFound);
  }

  Namespace* namespace_find(const std::string& name,  const bool exceptionWhenNotFound = true) noexcept(false);

  const Namespace* namespace_find(const char* name, const bool exceptionWhenNotFound = true) const noexcept(false) {
    return const_cast <Node*>(this)->namespace_find(name, exceptionWhenNotFound);
  }

  const Namespace* namespace_find(const std::string& name, const bool exceptionWhenNotFound = true) const noexcept(false) {
    return const_cast <Node*>(this)->namespace_find(name, exceptionWhenNotFound);
  }

  void clear() ;

  std::string asString() const ;

  static Node* node(child_iterator& ii) { return *ii; }

  static const Node* node(const_child_iterator& ii) { return *ii; }

  static const Attribute* attribute(const_attribute_iterator& ii) { return *ii; }

  static const Namespace* xnamespace(const_namespace_iterator& ii) { return namespace_container::data(ii);; }

protected:
  static Attribute* attribute(attribute_iterator& ii) { return *ii; }

private:
  std::string a_name;
  const Node* a_parent;
  Node* a_root;
  Children a_children;
  Attributes a_attributes;
  Text* a_text;
  const Namespace* a_namespace;

  // Esta instancia sólo la creará el nodo root.
  namespace_container* a_namespaces;

  typedef Recycler <Node> node_pool;
  typedef Recycler <Attribute> attribute_pool;
  typedef Recycler <Text> text_pool;

  typedef Recycler <Namespace> namespace_pool;

  node_pool* a_node_pool;
  attribute_pool* a_attribute_pool;
  text_pool* a_text_pool;
  namespace_pool* a_namespace_pool;

  /* Para evitar que se pueda crear desde el exterior */
  Node();

  void setRoot(Node* root) { a_root = root; }
  void setName(const char* name) { a_name = name; }

  static const Attribute* find(const char* attrName, const_attribute_iterator, const_attribute_iterator) ;

  // Allow sort in compiler
  attribute_iterator attribute_begin() { return a_attributes.begin(); }
  attribute_iterator attribute_end() { return a_attributes.end(); }

  friend class Parser;
  friend class Allocator<Node>;
  friend class XPath;
  friend class Decompressor;
  friend class Compiler;
};

}
}

#endif