Element.h

// -*- C++ -*-
//
// Element.hpp is a part of myXML
// Copyright (C) 2012-2019 Simon Platzer, The Herwig Collaboration
//
// myXML is licenced under version 3 of the GPL, see COPYING for details.
//
 
#ifndef MYXML_Element_hpp_included
#define MYXML_Element_hpp_included
 
#include <string>
#include <map>
#include <list>
#include <sstream>
#include <iomanip>
 
namespace XML {
 
  namespace ElementTypes {
 
    enum EnumerateElementTypes {
 
      Unknown = -1,
      Root = 0,
      EmptyElement = 1,
      Element = 2,
      ProcessingInstruction = 3,
      CharacterData = 4,
      ParsedCharacterData = 5,
      Comment = 6
    };
 
  }
 
  class Element {
 
  public:
 
    Element()
      : theType(ElementTypes::Unknown) {}
 
    explicit Element(int newType,
                     const std::string& newNameOrContent = "")
      : theType(newType), theNameOrContent(newNameOrContent) {}
 
 
    Element(const Element& other);
 
    Element& operator=(const Element& other);
  
    friend bool operator==(const XML::Element &one, const XML::Element &two);
    friend bool operator!=(const XML::Element &one, const XML::Element &two);
 
    friend XML::Element operator+(const XML::Element& one, const XML::Element& two);
    
  public:
 
    int type() const { return theType; }
 
    const std::string& name() const;
 
  public:
 
    const std::string& content() const;
 
    std::string& content();
 
    template<class T>
    Element& operator<<(const T& t) {
      assertContent();
      std::ostringstream out;
      out << std::setprecision(16) << t;
      theNameOrContent += out.str();
      return *this;
    }
 
  public:
 
    bool hasAttributes() const {
      return 
        type() == ElementTypes::Element ||
        type() == ElementTypes::EmptyElement;
    }
 
    bool hasAttribute(const std::string&) const;
 
    const std::map<std::string,std::string>& attributes() const;
 
    const std::string& attribute(const std::string&) const;
 
    std::string& attribute(const std::string&);
 
    struct Attribute {
 
      std::string name;
 
      std::string value;
 
      template<class T>
      Attribute(const std::string& newName,
                const T& newValue)
        : name(newName) {
        std::ostringstream valueOut;
        valueOut << std::setprecision(16) << newValue;
        value = valueOut.str();
        
 
          
      }
        
    inline bool operator==(const Attribute& other) {
      return ( name == other.name &&
      value == other.value);
    }
    inline bool operator!=(const Attribute& other) {
      return !(*this == other);
    }
    };
 
    Element& operator<<(const Attribute&);
 
    template<class T>
    void appendAttribute(const std::string& name, const T& t) {
      *this << Attribute(name,t);
    }
 
    template<class T>
    void getFromAttribute(const std::string& name, T& t) const {
      std::istringstream in(attribute(name));
      in >> std::setprecision(16) >> t;
    }
 
  public:
 
    bool hasChildren() const {
      return 
        type() == ElementTypes::Root ||
        type() == ElementTypes::Element;
    }
 
    const std::list<Element>& children() const;
 
    std::list<Element>& children();
 
    Element& append(const Element&);
 
    Element& prepend(const Element&);
 
    Element& operator<<(const Element&);
 
    void insert(std::list<Element>::iterator, const Element&);
 
    void erase(std::list<Element>::iterator);
 
    std::list<Element>::const_iterator 
    findFirst(int type, const std::string& name) const;
 
    std::pair<std::multimap<std::pair<int,std::string>,std::list<Element>::iterator>::const_iterator,
              std::multimap<std::pair<int,std::string>,std::list<Element>::iterator>::const_iterator>
    findAll(int type, const std::string& name) const;
 
  private:
 
    int theType;
 
    std::string theNameOrContent;
 
    std::map<std::string,std::string> theAttributes;
 
    std::list<Element> theChildren;
 
    std::multimap<std::pair<int,std::string>,std::list<Element>::iterator> theIndex;
 
  private:
 
    void index();
 
    void assertContent() const;
 
    void assertNamed() const;
 
    void assertAttributes() const;
 
    void assertChildren() const;
 
  };
 
}
 
#endif // MYXML_Element_hpp_included