Branch.h

Go to the documentation of this file.

#ifndef _utl_Branch_h_
#define _utl_Branch_h_

#include <utl/TimeStamp.h>
#include <utl/TabulatedFunction.h>
#include <utl/AugerException.h>

#include <xercesc/dom/DOM.hpp>
#include <boost/shared_ptr.hpp>

// stuff we want to be able to GetData()
#include <vector>
#include <list>
#include <map>

#include <sstream>


namespace utl {

  class Reader;
  class Deprecator;

  class Function;

  typedef std::map<std::string, std::string> AttributeMap;


  class BranchOwner {
  public:
    BranchOwner(xercesc::DOMDocument* const doc) : fDocument(doc) { }
    ~BranchOwner() { if (fDocument) fDocument->release(); }

    xercesc::DOMDocument* GetDocument() const { return fDocument; }

  private:
    BranchOwner(const BranchOwner&);
    BranchOwner& operator=(const BranchOwner&);

    xercesc::DOMDocument* fDocument = nullptr;
  };


  class Branch {

  public:
    Branch() = default;

    Branch(const Branch& branch) = default;

    Branch& operator=(const Branch& b);

  private:
    Branch(xercesc::DOMDocument* const doc, xercesc::DOMNode* const docBranch)
      : fOwner(new BranchOwner(doc)), fDOMNode(docBranch) { }

    Branch(const boost::shared_ptr<BranchOwner>& doc, xercesc::DOMNode* const docBranch)
      : fOwner(doc), fDOMNode(docBranch) { }

    bool HasTopBranch() const { return bool(*this) && GetDOMNode()->getOwnerDocument(); }

    Branch GetTopBranch() const;

  public:
    Branch GetParent() const;


    Branch GetFirstChild() const;


    Branch GetChild(const std::string& childName) const;


    Branch GetChild(const std::string& childName, const std::string& attributes) const;


    Branch GetChild(const std::string& childName, AttributeMap attributeMap) const;

    unsigned int GetNChildren() const;


    Branch GetNextSibling() const;

    Branch& operator++() { return operator=(GetNextSibling()); }


    Branch GetPreviousSibling() const;

    Branch& operator--() { return operator=(GetPreviousSibling()); }


    Branch GetSibling(const std::string& childName) const;


    Branch GetSibling(const std::string& childName, const std::string& multiID) const;


    Branch GetSibling(const std::string& childName, AttributeMap& attributeMap) const;


    AttributeMap GetAttributes() const;

    // for cases that do not need unit conversion

    // bool
    void GetData(bool& b) const;
    void GetData(std::vector<bool>& b) const;
    void GetData(std::list<bool>& b) const;
    // string
    void GetData(std::string& s) const;
    void GetData(std::vector<std::string>& s) const;
    void GetData(std::list<std::string>& s) const;
    // char*
    void GetData(char*& c) const;
    // TimeStamp
    void GetData(utl::TimeStamp& t) const;
    void GetData(std::vector<utl::TimeStamp>& vt) const;
    // TabulatedFunction
    void GetData(utl::TabulatedFunction& tf) const;

    void GetData(utl::Function& tf) const;


    template<typename T>
    void GetData(T& a) const { CastData(a); a *= static_cast<T>(GetUnit()); }


    template<typename T, class A, template<typename, typename> class W>
    void
    GetData(W<T, A>& a)
      const
    {
      // a = W<T, A>(); <-- at some point we should make sure that the argument is clear'd
      CastData(a);
      T u = static_cast<T>(GetUnit());
      for (auto& x : a)
        x *= u;
    }

    template<typename T1, typename T2>
    void
    GetData(std::pair<T1, T2>& p)
      const
    {
      std::istringstream is(GetDataString());
      if (is >> p.first >> std::ws >> p.second) {
        p.first *= static_cast<T1>(GetUnit());
        p.second *= static_cast<T2>(GetUnit());
      } else
        throw XMLParseException("Parsing pair failed!");
    }

    template<typename T>
    T Get() const { T t; GetData(t); return t; }

    Branch Clone() const;

    std::string String() const;

    void SetWarning(const std::string& wrn) { fWarning = wrn; }

    explicit operator bool() const { return bool(fOwner) && GetDOMNode(); }

    std::string GetName() const;

    std::string GetDataString() const;

    bool operator==(const Branch& b) const { return b.GetDOMNode() == GetDOMNode(); }

    bool operator!=(const Branch& b) const { return !operator==(b); }

    xercesc::DOMNode* GetDOMNode() const { return fDOMNode; }

  private:
    template<typename T>
    void
    CastData(T& dataT)
      const
    {
      std::istringstream is(GetDataString());
      is >> dataT;
    }

    template<typename T, class A, template<typename, typename> class W>
    void
    CastData(W<T, A>& v)
      const
    {
      const std::string dataString = GetDataString();
      std::istringstream is(dataString);
      T value;
      while (is >> value)
        v.push_back(value);
    }

    double GetUnit() const;
    std::vector<std::string> GetListOfVariables() const;

    inline void ZeroBranchCheck() const;

    // this here to guaranteee that the pointed data is still allocated when
    // the Reader goes out of scope.
    boost::shared_ptr<BranchOwner> fOwner;

    mutable xercesc::DOMNode* fDOMNode = nullptr;

    std::string fWarning;

    friend class Reader;

  };

}


#endif