ticpp.h

Go to the documentation of this file.

/*
http://code.google.com/p/ticpp/
Copyright (c) 2006 Ryan Pusztai, Ryan Mulder
 
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
the Software, and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:
 
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/

#define TIXML_USE_TICPP
#ifdef TIXML_USE_TICPP
 
#ifndef TICPP_INCLUDED
#define TICPP_INCLUDED
 
#include "ticpprc.h"
#include "tinyxml.h"
 
#include <exception>
#include <memory>
#include <sstream>
#include <typeinfo>
#include <vector>

namespace ticpp {
  class Exception : public std::exception {
    public:
    Exception(const std::string& details);
    ~Exception() throw();

    const char* what() const throw();
 
    std::string m_details; 
  };

#define TICPPTHROW(message)                                            \
  {                                                                    \
    std::ostringstream full_message;                                   \
    std::string        file(  __FILE__);                                 \
    file = file.substr(file.find_last_of("\\/") + 1);                  \
    full_message << message << " <" << file << "@" <<   __LINE__ << ">"; \
    full_message << BuildDetailedErrorString();                        \
    throw Exception(full_message.str());                               \
  }
 
  // Forward Declarations for Visitor, and others.
  class Document;
  class Element;
  class Declaration;
  class StylesheetReference;
  class Text;
  class Comment;
  class Attribute;

  class Visitor : public TiXmlVisitor {
    public:
    // Overload the TiXmlVisitor functions, wrap objects, call ticpp::Visitor
    // functions
    virtual bool VisitEnter(const TiXmlDocument& doc);
    virtual bool VisitExit(const TiXmlDocument& doc);
    virtual bool VisitEnter(const TiXmlElement&   element,
                            const TiXmlAttribute* firstAttribute);
    virtual bool VisitExit(const TiXmlElement& element);
    virtual bool Visit(const TiXmlDeclaration& declaration);
    virtual bool Visit(const TiXmlStylesheetReference& stylesheet);
    virtual bool Visit(const TiXmlText& text);
    virtual bool Visit(const TiXmlComment& comment);
    virtual bool Visit(const TiXmlUnknown& /*unknown*/);
 
    public:
    virtual bool VisitEnter(const Document& /*doc*/) { return true; }
    virtual bool VisitExit(const Document& /*doc*/) { return true; }

    virtual bool VisitEnter(const Element& /*element*/,
                            const Attribute* /*firstAttribute*/) {
      return true;
    }

    virtual bool VisitExit(const Element& /*element*/) { return true; }

    virtual bool Visit(const Declaration& /*declaration*/) { return true; }
    virtual bool Visit(const StylesheetReference& /*stylesheet*/) { return true; }
    virtual bool Visit(const Text& /*text*/) { return true; }
    virtual bool Visit(const Comment& /*comment*/) { return true; }
  };

  class Base {
    public:
    template < class T >
    std::string ToString(const T& value) const {
      std::stringstream convert;
      convert << value;
 
      if (convert.fail()) {
        TICPPTHROW("Could not convert value to text");
      }
 
      return convert.str();
    }
 
    std::string ToString(const std::string& value) const { return value; }

    template < class T >
    void FromString(const std::string& temp, T* out) const {
      std::istringstream val(temp);
      val >> *out;
 
      if (val.fail()) {
        TICPPTHROW("Could not convert \"" << temp << "\" to target type");
      }
    }

    void FromString(const std::string& temp, std::string* out) const {
      *out = temp;
    }

    int Row() const { return GetBasePointer()->Row(); }

    int Column() const { return GetBasePointer()->Column(); }

    bool operator==(const Base& rhs) const {
      return (GetBasePointer() == rhs.GetBasePointer());
    }

    bool operator!=(const Base& rhs) const {
      return (GetBasePointer() != rhs.GetBasePointer());
    }

    std::string BuildDetailedErrorString() const {
      std::ostringstream full_message;
#ifndef TICPP_NO_RTTI
      TiXmlNode* node = dynamic_cast< TiXmlNode* >(GetBasePointer());
 
      if (node != 0) {
        TiXmlDocument* doc = node->GetDocument();
 
        if (doc != 0) {
          if (doc->Error()) {
            full_message << "\nDescription: " << doc->ErrorDesc() << "\nFile: "
                         << (strlen(doc->Value()) > 0 ? doc->Value()
                                                      : "<unnamed-file>")
                         << "\nLine: " << doc->ErrorRow()
                         << "\nColumn: " << doc->ErrorCol();
          }
        }
      }
 
#endif
      return full_message.str();
    }

    virtual ~Base() {}
 
    protected:
    mutable TiCppRCImp* m_impRC; 

    void SetImpRC(TiXmlBase* nodeBase) { m_impRC = nodeBase->m_tiRC; }
 
    void ValidatePointer() const {
      if (m_impRC->IsNull()) {
        TICPPTHROW("Internal TiXml Pointer is nullptr");
      }
    }

    virtual TiXmlBase* GetBasePointer() const = 0;
  };

  class Attribute : public Base {
    private:
    TiXmlAttribute* m_tiXmlPointer;
    TiXmlBase*      GetBasePointer() const {
      ValidatePointer();
      return m_tiXmlPointer;
    }
 
    public:
    Attribute();

    Attribute(const std::string& name, const std::string& value);

    Attribute(TiXmlAttribute* attribute);

    template < class T >
    void GetValue(T* value) const {
      ValidatePointer();
      FromString(m_tiXmlPointer->ValueStr(), value);
    }

    std::string Value() const;

    template < class T >
    void SetValue(const T& value) {
      ValidatePointer();
      m_tiXmlPointer->SetValue(ToString(value));
    }

    template < class T >
    void GetName(T* name) const {
      ValidatePointer();
      FromString(m_tiXmlPointer->Name(), name);
    }

    std::string Name() const;

    template < class T >
    void SetName(const T& name) {
      ValidatePointer();
      m_tiXmlPointer->SetName(ToString(name));
    }

    void operator=(const Attribute& copy);

    Attribute(const Attribute& copy);
 
    /*
    Decrements reference count.
    */
    ~Attribute();

    Attribute* Next(bool throwIfNoAttribute = true) const;

    Attribute* Previous(bool throwIfNoAttribute = true) const;

    void IterateNext(const std::string&, Attribute** next) const;

    void IteratePrevious(const std::string&, Attribute** previous) const;

    virtual void Print(FILE* file, int depth) const;
 
    private:
    void SetTiXmlPointer(TiXmlAttribute* newPointer);
  };

  class Node : public Base {
    public:
    template < class T >
    void GetValue(T* value) const {
      FromString(GetTiXmlPointer()->ValueStr(), value);
    }

    std::string Value() const;

    template < class T >
    void SetValue(const T& value) {
      GetTiXmlPointer()->SetValue(ToString(value));
    }

    void Clear();

    Node* Parent(bool throwIfNoParent = true) const;

    Node* FirstChild(bool throwIfNoChildren = true) const;

    Node* FirstChild(const char* value, bool throwIfNoChildren = true) const;

    Node* FirstChild(const std::string& value,
                     bool               throwIfNoChildren = true) const;

    Node* LastChild(bool throwIfNoChildren = true) const;

    Node* LastChild(const char* value, bool throwIfNoChildren = true) const;

    Node* LastChild(const std::string& value, bool throwIfNoChildren = true) const;

    Node* IterateChildren(Node* previous) const;

    Node* IterateChildren(const std::string& value, Node* previous) const;

    Node* InsertEndChild(Node& addThis);

    Node* LinkEndChild(Node* childNode);

    Node* InsertBeforeChild(Node* beforeThis, Node& addThis);

    Node* InsertAfterChild(Node* afterThis, Node& addThis);

    Node* ReplaceChild(Node* replaceThis, Node& withThis);

    void RemoveChild(Node* removeThis);

    Node* PreviousSibling(bool throwIfNoSiblings = true) const;

    Node* PreviousSibling(const std::string& value,
                          bool               throwIfNoSiblings = true) const;

    Node* PreviousSibling(const char* value, bool throwIfNoSiblings = true) const;

    Node* NextSibling(bool throwIfNoSiblings = true) const;

    Node* NextSibling(const std::string& value,
                      bool               throwIfNoSiblings = true) const;

    Node* NextSibling(const char* value, bool throwIfNoSiblings = true) const;

    template < class T >
    void IterateFirst(const std::string& value, T** first) const {
      *first = 0;
 
      for (Node* child = FirstChild(value, false); child;
           child = child->NextSibling(value, false)) {
        *first = dynamic_cast< T* >(child);
 
        if (0 != *first) {
          return;
        }
      }
    }
 
    virtual void IterateFirst(const std::string&, Attribute**) const {
      TICPPTHROW("Attributes can only be iterated with Elements.")
    }

    template < class T >
    void IterateNext(const std::string& value, T** next) const {
      Node* sibling = NextSibling(value, false);
      *next = dynamic_cast< T* >(sibling);
 
      while ((0 != sibling) && (0 == *next)) {
        sibling = sibling->NextSibling(value, false);
        *next = dynamic_cast< T* >(sibling);
      }
    }

    template < class T >
    void IteratePrevious(const std::string& value, T** previous) const {
      Node* sibling = PreviousSibling(value, false);
      *previous = dynamic_cast< T* >(sibling);
 
      while ((0 != sibling) && (0 == *previous)) {
        sibling = sibling->PreviousSibling(value, false);
        *previous = dynamic_cast< T* >(sibling);
      }
    }

    Element* NextSiblingElement(bool throwIfNoSiblings = true) const;

    Element* NextSiblingElement(const std::string& value,
                                bool               throwIfNoSiblings = true) const;

    Element* NextSiblingElement(const char* value,
                                bool        throwIfNoSiblings = true) const;

    Element* FirstChildElement(bool throwIfNoChildren = true) const;

    Element* FirstChildElement(const char* value,
                               bool        throwIfNoChildren = true) const;

    Element* FirstChildElement(const std::string& value,
                               bool               throwIfNoChildren = true) const;

    int Type() const;

    Document* GetDocument(bool throwIfNoDocument = true) const;

    bool NoChildren() const;
 
#ifndef TICPP_NO_RTTI
    template < class T >
    T* To() const {
      T* pointer = dynamic_cast< T* >(this);
 
      if (0 == pointer) {
        std::string thisType = typeid(this).name();
        std::string targetType = typeid(T).name();
        std::string thatType = typeid(*this).name();
        TICPPTHROW("The " << thisType.substr(6) << " could not be casted to a "
                          << targetType.substr(6)
                          << " *, because the target object is not a "
                          << targetType.substr(6)
                          << ". (It is a "
                          << thatType.substr(6)
                          << ")");
      }
 
      return pointer;
    }
#endif

    Document* ToDocument() const;

    Element* ToElement() const;

    Comment* ToComment() const;

    Text* ToText() const;

    Declaration* ToDeclaration() const;

    StylesheetReference* ToStylesheetReference() const;

    std::unique_ptr< Node > Clone() const;

    bool Accept(TiXmlVisitor* visitor) const;

    friend std::istream& operator>>(std::istream& in, Node& base) {
      in >> *base.GetTiXmlPointer();
      return in;
    }

    friend std::ostream& operator<<(std::ostream& out, const Node& base) {
      out << *base.GetTiXmlPointer();
      return out;
    }
 
    protected:
    virtual TiXmlNode* GetTiXmlPointer() const = 0;
 
    TiXmlBase* GetBasePointer() const { return GetTiXmlPointer(); }

    Node* NodeFactory(TiXmlNode* tiXmlNode,
                      bool       throwIfNull = true,
                      bool       rememberSpawnedWrapper = true) const;
  };

  template < class T = Node >
  class Iterator {
    private:
    T*          m_p;     
    std::string m_value; 
 
    public:
    T* begin(const Node* parent) const {
      T* pointer;
      parent->IterateFirst(m_value, &pointer);
      return pointer;
    }

    T* end() const { return 0; }

    Iterator(const std::string& value = "")
        : m_p(0)
        , m_value(value) {}

    Iterator(T* node, const std::string& value = "")
        : m_p(node)
        , m_value(value) {}

    Iterator(const Iterator& it)
        : m_p(it.m_p)
        , m_value(it.m_value) {}

    T* Get() const { return m_p; }

    Iterator& operator=(const Iterator& it) {
      m_p = it.m_p;
      m_value = it.m_value;
      return *this;
    }

    Iterator& operator=(T* p) {
      m_p = p;
      return *this;
    }

    Iterator& operator++() {
      m_p->IterateNext(m_value, &m_p);
      return *this;
    }

    Iterator operator++(int) {
      Iterator tmp(*this);
      ++(*this);
      return tmp;
    }

    Iterator& operator--() {
      m_p->IteratePrevious(m_value, &m_p);
      return *this;
    }

    Iterator operator--(int) {
      Iterator tmp(*this);
      --(*this);
      return tmp;
    }

    bool operator!=(const T* p) const {
      if (m_p == p) {
        return false;
      }
 
      if (0 == m_p || 0 == p) {
        return true;
      }
 
      return *m_p != *p;
    }

    bool operator!=(const Iterator& it) const { return operator!=(it.m_p); }

    bool operator==(T* p) const {
      if (m_p == p) {
        return true;
      }
 
      if (0 == m_p || 0 == p) {
        return false;
      }
 
      return *m_p == *p;
    }

    bool operator==(const Iterator& it) const { return operator==(it.m_p); }

    T* operator->() const { return m_p; }

    T& operator*() const { return *m_p; }
  };

  template < class T >
  class NodeImp : public Node {
    protected:
    T* m_tiXmlPointer; 

    TiXmlNode* GetTiXmlPointer() const {
      ValidatePointer();
      return m_tiXmlPointer;
    }

    void SetTiXmlPointer(T* newPointer) {
      m_tiXmlPointer = newPointer;
      SetImpRC(newPointer);
    }

    NodeImp(T* tiXmlPointer) {
      // Check for nullptr pointers
      if (0 == tiXmlPointer) {
#ifdef TICPP_NO_RTTI
        TICPPTHROW("Can not create TinyXML objext");
#else
        TICPPTHROW("Can not create a " << typeid(T).name());
#endif
      }
 
      SetTiXmlPointer(tiXmlPointer);
      m_impRC->IncRef();
    }

    virtual void operator=(const NodeImp< T >& copy) {
      // Dropping the reference to the old object
      this->m_impRC->DecRef();
 
      // Pointing to the new Object
      SetTiXmlPointer(copy.m_tiXmlPointer);
 
      // The internal tixml pointer changed in the above line
      this->m_impRC->IncRef();
    }

    NodeImp(const NodeImp< T >& copy)
        : Node(copy) {
      // Pointing to the new Object
      SetTiXmlPointer(copy.m_tiXmlPointer);
 
      // The internal tixml pointer changed in the above line
      this->m_impRC->IncRef();
    }
 
    public:
    /*
    Deletes the spawned wrapper objects.
    Decrements reference count.
    */
    virtual ~NodeImp() { m_impRC->DecRef(); }
  };

  class Comment : public NodeImp< TiXmlComment > {
    private:   // best attempt to get rid of overloaded virtual warnings
    using  NodeImp< TiXmlComment >::operator=;
 
    public:
    Comment();

    Comment(TiXmlComment* comment);

    Comment(const std::string& comment);
  };

  class Text : public NodeImp< TiXmlText > {
    private:   // best attempt to get rid of overloaded virtual warnings
    using  NodeImp< TiXmlText >::operator=;
    public:
    Text();

    Text(TiXmlText* text);

    Text(const std::string& value);

    template < class T >
    Text(const T& value)
        : NodeImp< TiXmlText >(new TiXmlText(ToString(value))) {
      m_impRC->InitRef();
    }
  };

  class Document : public NodeImp< TiXmlDocument > {
    private:   // best attempt to get rid of overloaded virtual warnings
    using  NodeImp< TiXmlDocument >::operator=;
    public:
    Document();

    Document(TiXmlDocument* document);

    Document(const char* documentName);

    Document(const std::string& documentName);

    void LoadFile(TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING);

    void SaveFile() const;

    void LoadFile(const std::string& filename,
                  TiXmlEncoding      encoding = TIXML_DEFAULT_ENCODING);

    void LoadFile(const char*   filename,
                  TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING);

    void SaveFile(const std::string& filename) const;

    void Parse(const std::string& xml,
               bool               throwIfParseError = true,
               TiXmlEncoding      encoding = TIXML_DEFAULT_ENCODING);
  };

  class Element : public NodeImp< TiXmlElement > {
    private:   // best attempt to get rid of overloaded virtual warnings
    using  NodeImp< TiXmlElement >::operator=;
 
    public:
    Element();

    Element(const std::string& value);

    Element(const char* value);

    Element(TiXmlElement* element);

    template < class T >
    Element(const std::string& value, const T& text)
        : NodeImp< TiXmlElement >(new TiXmlElement(value)) {
      m_impRC->InitRef();
      SetText(text);
    }

    Attribute* FirstAttribute(bool throwIfNoAttributes = true) const;

    Attribute* LastAttribute(bool throwIfNoAttributes = true) const;

    void IterateFirst(const std::string&, Attribute** first) const {
      *first = 0;
 
      for (Attribute* child = FirstAttribute(false); child;
           child = child->Next(false)) {
        *first = dynamic_cast< Attribute* >(child);
 
        if (0 != *first) {
          return;
        }
      }
    }

    template < class T >
    void SetAttribute(const std::string& name, const T& value) {
      ValidatePointer();
      m_tiXmlPointer->SetAttribute(name, ToString(value));
    }

    std::string GetText(bool throwIfNotFound = true) const {
      // Get the element's text value as a std::string
      std::string temp;
 
      if (!GetTextImp(&temp)) {
        if (throwIfNotFound) {
          TICPPTHROW("Text does not exists in the current element");
        }
      }
 
      return temp;
    }

    std::string GetTextOrDefault(const std::string& defaultValue) const {
      // Get the element's text value as a std::string
      std::string temp;
 
      if (!GetTextImp(&temp)) {
        return defaultValue;
      }
 
      return temp;
    }

    template < class T, class DefaultT >
    void GetTextOrDefault(T* value, const DefaultT& defaultValue) const {
      // Get the element's text value as a std::string
      std::string temp;
 
      if (!GetTextImp(&temp)) {
        // The text value does not exist - set value to the default
        *value = defaultValue;
        return;
      }
 
      // Stream the value from the string to T
      FromString(temp, value);
    }

    template < class T >
    void GetText(T* value, bool throwIfNotFound = true) const {
      // Get the element's text value as a std::string
      std::string temp;
 
      if (!GetTextImp(&temp)) {
        if (throwIfNotFound) {
          TICPPTHROW("Text does not exists in the current element");
        } else {
          return;
        }
      }
 
      // Stream the value from the string to T
      FromString(temp, value);
    }

    template < class T >
    void SetText(const T& value) {
      ValidatePointer();
      std::string temp = ToString(value);
 
      if (m_tiXmlPointer->NoChildren()) {
        m_tiXmlPointer->LinkEndChild(new TiXmlText(temp));
      } else {
        if (0 == m_tiXmlPointer->GetText()) {
          m_tiXmlPointer->InsertBeforeChild(m_tiXmlPointer->FirstChild(),
                                            TiXmlText(temp));
        } else {
          // There already is text, so change it
          m_tiXmlPointer->FirstChild()->SetValue(temp);
        }
      }
    }

    template < class T, class DefaulT >
    void GetAttributeOrDefault(const std::string& name,
                               T*                 value,
                               const DefaulT&     defaultValue) const {
      // Get the attribute's value as a std::string
      std::string temp;
 
      if (!GetAttributeImp(name, &temp)) {
        // The attribute does not exist - set value to the default
        *value = defaultValue;
        return;
      }
 
      // Stream the value from the string to T
      FromString(temp, value);
    }

    std::string GetAttributeOrDefault(const std::string& name,
                                      const std::string& defaultValue) const;

    template < class T >
    T GetAttribute(const std::string& name, bool throwIfNotFound = true) const {
      // Get the attribute's value as a std::string
      std::string temp;
      T           value;
 
      if (!GetAttributeImp(name, &temp)) {
        if (throwIfNotFound) {
          const std::string error(std::string("Attribute '") + name +
                                  std::string("' does not exist"));
          TICPPTHROW(error);
        }
      } else {
        // Stream the value from the string to T
        FromString(temp, &value);
      }
 
      return value;
    }

    template < class T >
    void GetAttribute(const std::string& name,
                      T*                 value,
                      bool               throwIfNotFound = true) const {
      // Get the attribute's value as a std::string
      std::string temp;
 
      if (!GetAttributeImp(name, &temp)) {
        if (throwIfNotFound) {
          const std::string error(std::string("Attribute '") + name +
                                  std::string("' does not exist"));
          TICPPTHROW(error);
        } else {
          return;
        }
      }
 
      // Stream the value from the string to T
      FromString(temp, value);
    }

    std::string GetAttribute(const std::string& name) const;

    bool HasAttribute(const std::string& name) const;

    void RemoveAttribute(const std::string& name);
 
    private:
    bool GetAttributeImp(const std::string& name, std::string* value) const;

    bool GetTextImp(std::string* value) const;
  };

  class Declaration : public NodeImp< TiXmlDeclaration > {
    private:   // best attempt to get rid of overloaded virtual warnings
    using  NodeImp< TiXmlDeclaration >::operator=;
    public:
    Declaration();

    Declaration(TiXmlDeclaration* declaration);

    Declaration(const std::string& version,
                const std::string& encoding,
                const std::string& standalone);

    std::string Version() const;

    std::string Encoding() const;

    std::string Standalone() const;
  };

  class StylesheetReference : public NodeImp< TiXmlStylesheetReference > {
    private:   // best attempt to get rid of overloaded virtual warnings
    using  NodeImp< TiXmlStylesheetReference >::operator=;
    public:
    StylesheetReference();

    StylesheetReference(TiXmlStylesheetReference* stylesheetReference);

    StylesheetReference(const std::string& type, const std::string& href);

    std::string Type() const;

    std::string Href() const;
  };
}
 
#endif  // TICPP_INCLUDED
 
#endif  // TIXML_USE_TICPP