ixmlnode.h

Go to the documentation of this file.

/*
 * Copyright 2021 Ingemar Hedvall
 * SPDX-License-Identifier: MIT
 */
#pragma once
 
#include <memory>
#include <sstream>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "util/stringutil.h"
 
namespace {
template<typename T>
T XValue(const std::string &value) {
  std::string v(value);
  util::string::Trim(v);
  std::istringstream temp(v);
  T out = {};
  temp >> out;
  return out;
}
 
template<>
bool XValue(const std::string &value) {
  std::string v(value);
  util::string::Trim(v);
  return util::string::IEquals(v, "1") || util::string::IEquals(v, "ON") ||
         util::string::IEquals(v, "T", 1)      // True/False
         || util::string::IEquals(v, "Y", 1);  // Yes/No
}
 
template<>
std::string XValue(const std::string &value) {
  std::string v(value);
  util::string::Trim(v);
  return v;
}
 
}  // end namespace
 
namespace util::xml {

class IXmlNode {
 public:
  explicit IXmlNode(const std::string &tag_name);  
  virtual ~IXmlNode() = default;                   
 
  IXmlNode() = delete;

  [[nodiscard]] std::string TagName() const { return tag_name_; }

  void TagName(const std::string &name) { tag_name_ = name; }

  [[nodiscard]] bool IsTagName(const std::string &tag) const;

  [[nodiscard]] bool IsAttribute(const std::string &key,
                                 const std::string &value) const;

  template<typename T>
  [[nodiscard]] T Attribute(const std::string &key, const T &def = {}) const {
    for (const auto &p : attribute_list_) {
      if (util::string::IEquals(p.first, key)) {
        return XValue<T>(p.second);
      }
    }
    return def;
  }

  template<typename T>
  void SetAttribute(const std::string &key, const T &value);

  template<typename T>
  [[nodiscard]] T Value() const {
    return XValue<T>(value_);
  }

  template<typename T>
  void Value(const T &value);

  template<typename T>
  [[nodiscard]] T Property(const std::string &key, const T &def = {}) const {
    const IXmlNode *node = GetNode(key);
    return node != nullptr ? node->Value<T>() : def;
  }

  template<typename T>
  void SetProperty(const std::string &key, const T &value) {
    auto &node = AddUniqueNode(key);
    node.Value(value);
  }

  using ChildList = std::vector<const IXmlNode *>;
 
  virtual void GetChildList(
      ChildList &child_list) const;  
  [[nodiscard]] virtual const IXmlNode *GetNode(
      const std::string &tag) const;  
  [[nodiscard]] virtual const IXmlNode *GetNode(const std::string &tag,
                                                const std::string &key,
                                                const std::string &attr)
  const;  

  [[nodiscard]] bool ExistProperty(const std::string &tag) const {
    return GetNode(tag) != nullptr;
  }
 
  virtual IXmlNode &AddNode(const std::string &name);  
  virtual IXmlNode &AddUniqueNode(
      const std::string &name);  
  virtual IXmlNode &AddUniqueNode(
      const std::string &name, const std::string &key,
      const std::string &attr);  
 
  virtual void AddNode(std::unique_ptr<IXmlNode> p);  
 
  void DeleteNode(const std::string &name); 
  void DeleteNode(const IXmlNode *node); 
 
  virtual void Write(std::ostream &dest,
                     size_t level);  

  [[nodiscard]] bool HasChildren() const {
    return !node_list_.empty();
  }
 
 protected:
  std::string tag_name_;  
  std::string value_;     

  using AttributeList = std::unordered_map<std::string, std::string>;
  AttributeList attribute_list_;  

  using NodeList = std::vector<std::unique_ptr<IXmlNode> >;
  NodeList node_list_;  
 
  [[nodiscard]] virtual std::unique_ptr<IXmlNode> CreateNode(
      const std::string &name) const;  
};
 
template<typename T>
void IXmlNode::Value(const T &value) {
  //  value_ = std::to_string(value);
  std::ostringstream temp;
  temp << value;
  value_ = temp.str();
}

template<>
void IXmlNode::Value(const bool &value);

template<>
void IXmlNode::Value(const std::string &value);
 
template<typename T>
void IXmlNode::SetAttribute(const std::string &key, const T &value) {
  std::ostringstream temp;
  temp << value;
  attribute_list_.insert({key, temp.str()});
}

template<>
void IXmlNode::SetAttribute(const std::string &key, const bool &value);
 
}  // namespace util::xml