XMLTag.hpp

Go to the documentation of this file.

#pragma once
 
#include <Eigen/Core>
#include <map>
#include <memory>
#include <optional>
#include <string>
#include <variant>
#include <vector>
#include "logging/Logger.hpp"
#include "xml/ConfigParser.hpp"
#include "xml/XMLAttribute.hpp"
 
namespace precice::xml {
class ConfigParser;
}
 
namespace precice::xml {
 
struct ConfigurationContext {
  std::string name;
  int         rank;
  int         size;
};
struct ConfigurationContext {…};
 
class XMLTag {
  friend class precice::xml::ConfigParser;
 
public:
  using Namespaces = typename std::vector<std::string>;
 
  using Subtags = typename std::vector<std::shared_ptr<XMLTag>>;
 
  using Attribute = std::variant<
      XMLAttribute<double>,
      XMLAttribute<int>,
      XMLAttribute<std::string>,
      XMLAttribute<bool>,
      XMLAttribute<Eigen::VectorXd>>;
 
  using Attributes = typename std::vector<Attribute>;
 
  struct Listener {
 
    Listener &operator=(Listener &&) = delete;
 
    virtual ~Listener() = default;
    virtual void xmlTagCallback(ConfigurationContext const &context, XMLTag &callingTag) = 0;
 
    virtual void xmlEndTagCallback(ConfigurationContext const &context, XMLTag &callingTag) = 0;
  };
  struct Listener {…};
 
  enum Occurrence {
    OCCUR_NOT_OR_ONCE,
    OCCUR_ONCE,
    OCCUR_ONCE_OR_MORE,
    OCCUR_ARBITRARY,
    OCCUR_ARBITRARY_NESTED
  };
  enum Occurrence {…};
 
  static std::string_view getOccurrenceString(Occurrence occurrence);
 
  XMLTag(
      Listener   &listener,
      std::string name,
      Occurrence  occurrence,
      std::string xmlNamespace = "");
 
  XMLTag &setDocumentation(std::string_view documentation);
 
  std::string getDocumentation() const
  {
    return _doc;
  };
  std::string getDocumentation() const {…}
 
  XMLTag &addNamespace(const std::string &namespaceName);
 
  XMLTag &addSubtag(const XMLTag &tag);
 
  const Subtags &getSubtags() const
  {
    return _subtags;
  };
  const Subtags &getSubtags() const {…}
 
  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) const;
 
  template <typename Container>
  void addSubtags(const Container &subtags)
  {
    std::for_each(subtags.begin(), subtags.end(), [this](auto &s) { this->addSubtag(s); });
  }
  void addSubtags(const Container &subtags) {…}
 
  const std::string &getName() const
  {
    return _name;
  }
  const std::string &getName() const {…}
 
  const std::string &getNamespace() const
  {
    return _namespace;
  }
  const std::string &getNamespace() const {…}
 
  const Namespaces &getNamespaces() const
  {
    return _namespaces;
  };
  const Namespaces &getNamespaces() const {…}
 
  const std::string &getFullName() const
  {
    return _fullName;
  }
  const std::string &getFullName() const {…}
 
  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;
 
  Eigen::VectorXd getEigenVectorXdAttributeValue(const std::string &name) const;
 
  std::vector<std::string> getAttributeNames() const;
 
  const Attributes &getAttributes() const
  {
    return _attributes;
  };
  const Attributes &getAttributes() const {…}
 
  bool isConfigured() const
  {
    return _configured;
  }
  bool isConfigured() const {…}
 
  Occurrence getOccurrence() const
  {
    return _occurrence;
  }
  Occurrence getOccurrence() const {…}
 
  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;
 
  Attributes _attributes;
 
  std::map<std::string, std::string> _attributeHints;
 
  void areAllSubtagsConfigured() const;
 
  void resetAttributes();
};
class XMLTag {…};
 
std::string getName(const XMLTag::Attribute &attribute);
 
// ------------------------------------------------------ HEADER IMPLEMENTATION
 
struct NoPListener : public XMLTag::Listener {
  void xmlTagCallback(ConfigurationContext const &context, XMLTag &callingTag) override {}
  void xmlEndTagCallback(ConfigurationContext const &context, XMLTag &callingTag) override {}
};
struct NoPListener : public XMLTag::Listener {…};
 
XMLTag getRootTag();
 
std::string configure(
    XMLTag                                   &tag,
    const precice::xml::ConfigurationContext &context,
    std::string_view                          configurationFilename);
 
} // namespace precice::xml