XMLTag.hpp

Go to the documentation of this file.

#pragma once
 
#include <Eigen/Core>
#include <map>
#include <memory>
#include <optional>
#include <set>
#include <string>
#include <vector>
#include "logging/Logger.hpp"
#include "xml/ConfigParser.hpp"
#include "xml/XMLAttribute.hpp"
 
namespace precice {
namespace xml {
class ConfigParser;
}
} // namespace precice
 
namespace precice {
namespace xml {
 
struct ConfigurationContext {
  std::string name;
  int         rank;
  int         size;
};
 
class XMLTag {
  friend class precice::xml::ConfigParser;
 
public:
  using Namespaces = typename std::vector<std::string>;
 
  using Subtags = typename std::vector<std::shared_ptr<XMLTag>>;
 
  template <typename T>
  using AttributeMap = typename std::map<std::string, XMLAttribute<T>>;
 
  struct Listener {
 
    Listener &operator=(Listener &&) = delete;
 
    virtual ~Listener(){};
    virtual void xmlTagCallback(ConfigurationContext const &context, XMLTag &callingTag) = 0;
 
    virtual void xmlEndTagCallback(ConfigurationContext const &context, XMLTag &callingTag) = 0;
  };
 
  enum Occurrence {
    OCCUR_NOT_OR_ONCE,
    OCCUR_ONCE,
    OCCUR_ONCE_OR_MORE,
    OCCUR_ARBITRARY,
    OCCUR_ARBITRARY_NESTED
  };
 
  static std::string getOccurrenceString(Occurrence occurrence);
 
  XMLTag(
      Listener &  listener,
      std::string name,
      Occurrence  occurrence,
      std::string xmlNamespace = "");
 
  XMLTag &setDocumentation(const std::string &documentation);
 
  std::string getDocumentation() const
  {
    return _doc;
  };
 
  XMLTag &addNamespace(const std::string &namespaceName);
 
  XMLTag &addSubtag(const XMLTag &tag);
 
  const Subtags &getSubtags() const
  {
    return _subtags;
  };
 
  //XMLTag& removeSubtag ( const std::string& tagName );
 
  XMLTag &addAttribute(const XMLAttribute<double> &attribute);
 
  // Adds a XML attribute by making a copy of the given attribute.
  XMLTag &addAttribute(const XMLAttribute<int> &attribute);
 
  XMLTag &addAttribute(const XMLAttribute<std::string> &attribute);
 
  XMLTag &addAttribute(const XMLAttribute<bool> &attribute);
 
  XMLTag &addAttribute(const XMLAttribute<Eigen::VectorXd> &attribute);
 
  void addAttributeHint(std::string name, std::string message);
 
  bool hasAttribute(const std::string &attributeName);
 
  template <typename Container>
  void addSubtags(const Container &subtags)
  {
    std::for_each(subtags.begin(), subtags.end(), [this](auto &s) { this->addSubtag(s); });
  }
 
  const std::string &getName() const
  {
    return _name;
  }
 
  const std::string &getNamespace() const
  {
    return _namespace;
  }
 
  const Namespaces &getNamespaces() const
  {
    return _namespaces;
  };
 
  const std::string &getFullName() const
  {
    return _fullName;
  }
 
  double getDoubleAttributeValue(const std::string &name, std::optional<double> default_value = std::nullopt) const;
 
  int getIntAttributeValue(const std::string &name, std::optional<int> default_value = std::nullopt) const;
 
  std::string getStringAttributeValue(const std::string &name, std::optional<std::string> default_value = std::nullopt) const;
 
  bool getBooleanAttributeValue(const std::string &name, std::optional<bool> default_value = std::nullopt) const;
 
  const AttributeMap<double> &getDoubleAttributes() const
  {
    return _doubleAttributes;
  };
 
  const AttributeMap<int> &getIntAttributes() const
  {
    return _intAttributes;
  };
 
  const AttributeMap<std::string> &getStringAttributes() const
  {
    return _stringAttributes;
  };
 
  const AttributeMap<bool> &getBooleanAttributes() const
  {
    return _booleanAttributes;
  };
 
  const AttributeMap<Eigen::VectorXd> &getEigenVectorXdAttributes() const
  {
    return _eigenVectorXdAttributes;
  };
 
  Eigen::VectorXd getEigenVectorXdAttributeValue(
      const std::string &name,
      int                dimensions) const;
 
  bool isConfigured() const
  {
    return _configured;
  }
 
  Occurrence getOccurrence() const
  {
    return _occurrence;
  }
 
  void clear();
 
  void readAttributes(const std::map<std::string, std::string> &aAttributes);
 
private:
  mutable logging::Logger _log{"xml::XMLTag"};
 
  Listener &_listener;
 
  std::string _name;
 
  std::string _namespace;
 
  std::string _fullName;
 
  std::string _doc;
 
  bool _configured = false;
 
  Occurrence _occurrence;
 
  Namespaces _namespaces;
 
  Subtags _subtags;
 
  std::map<std::string, bool> _configuredNamespaces;
 
  std::set<std::string> _attributes;
 
  AttributeMap<double> _doubleAttributes;
 
  AttributeMap<int> _intAttributes;
 
  AttributeMap<std::string> _stringAttributes;
 
  AttributeMap<bool> _booleanAttributes;
 
  AttributeMap<Eigen::VectorXd> _eigenVectorXdAttributes;
 
  std::map<std::string, std::string> _attributeHints;
 
  void areAllSubtagsConfigured() const;
 
  void resetAttributes();
};
 
// ------------------------------------------------------ HEADER IMPLEMENTATION
 
struct NoPListener : public XMLTag::Listener {
  void xmlTagCallback(ConfigurationContext const &context, XMLTag &callingTag) override {}
  void xmlEndTagCallback(ConfigurationContext const &context, XMLTag &callingTag) override {}
};
 
//NoPListener& getNoPListener();
 
XMLTag getRootTag();
 
void configure(
    XMLTag &                                  tag,
    const precice::xml::ConfigurationContext &context,
    std::string_view                          configurationFilename);
 
} // namespace xml
} // namespace precice
 
//std::ostream& operator<< (
//  std::ostream&                 os,
//  const precice::xml::XMLTag& tag );