From 6c6752e23b4fec21ddc388255ddad0056e4a8059 Mon Sep 17 00:00:00 2001
From: Andrea Iob <andrea_iob@hotmail.com>
Date: Tue, 8 Feb 2022 14:11:48 +0100
Subject: [PATCH 1/2] IO/config: add support for reading/writing XML attributes

---
 src/IO/configuration_JSON.cpp                 |   8 +-
 src/IO/configuration_XML.cpp                  |  59 ++++-
 src/IO/configuration_config.cpp               | 210 ++++++++++++++++--
 src/IO/configuration_config.hpp               |  39 +++-
 src/IO/configuration_config.tpp               |  69 +++++-
 .../IO/data/configuration.xml                 |  10 +-
 test/integration_tests/IO/test_IO_00004.cpp   |  20 +-
 7 files changed, 373 insertions(+), 42 deletions(-)

diff --git a/src/IO/configuration_JSON.cpp b/src/IO/configuration_JSON.cpp
index 50e34ad4d8..12625d9aca 100644
--- a/src/IO/configuration_JSON.cpp
+++ b/src/IO/configuration_JSON.cpp
@@ -264,13 +264,13 @@ void writeNode(const Config *config, rapidjson::Value &rootJSONData, rapidjson::
 {
     // Write the options
     for (const auto &entry : config->getOptions()) {
-        const std::string &configKey   = entry.first;
-        const std::string &configValue = entry.second;
+        const std::string &key = entry.first;
+        const Config::Option &option = entry.second;
 
         rapidjson::Value jsonKey;
-        jsonKey.SetString(configKey, allocator);
+        jsonKey.SetString(key, allocator);
 
-        rapidjson::Value jsonValue = encodeValue(configValue, allocator);
+        rapidjson::Value jsonValue = encodeValue(option.value, allocator);
 
         rootJSONData.AddMember(jsonKey, jsonValue, allocator);
     }
diff --git a/src/IO/configuration_XML.cpp b/src/IO/configuration_XML.cpp
index a709292e69..4d35d0a2dd 100644
--- a/src/IO/configuration_XML.cpp
+++ b/src/IO/configuration_XML.cpp
@@ -66,10 +66,22 @@ void readNode(xmlNodePtr root, Config *config)
             }
             readNode(node->children, section);
         } else {
+            Config::Option option;
+
             xmlChar *nodeContent = xmlNodeGetContent(node);
-            std::string value(reinterpret_cast<const char*>(nodeContent));
-            config->set(key, value);
+            option.value = reinterpret_cast<const char*>(nodeContent);
             xmlFree(nodeContent);
+
+            xmlAttr *attribute = node->properties;
+            while (attribute) {
+                xmlChar* attributeValue = xmlNodeListGetString(node->doc, attribute->children, 1);
+                option.attributes[reinterpret_cast<const char*>(attribute->name)] = reinterpret_cast<const char*>(attributeValue);
+                xmlFree(attributeValue);
+
+                attribute = attribute->next;
+            }
+
+            config->addOption(key, std::move(option));
         }
     }
 }
@@ -87,20 +99,49 @@ void writeNode(xmlTextWriterPtr writer, const Config *config, const std::string
 
     // Write the options
     for (const auto &entry : config->getOptions()) {
-        const std::string &key   = entry.first;
-        const std::string &value = entry.second;
+        const std::string &key = entry.first;
+        const Config::Option &option = entry.second;
 
+        // Start option
         xmlChar *elementName = encodeString(key, encoding);
-        xmlChar *elementText = encodeString(value, encoding);
-        int status = xmlTextWriterWriteFormatElement(writer, BAD_CAST elementName, "%s", elementText);
+        status = xmlTextWriterStartElement(writer, BAD_CAST elementName);
+        if (elementName) {
+            xmlFree(elementName);
+        }
+        if (status < 0) {
+            throw std::runtime_error("Error at xmlTextWriterStartElement");
+        }
+
+        // Write option attributes
+        for (const auto &attributeEntry : option.attributes) {
+            xmlChar *attributeName  = encodeString(attributeEntry.first, encoding);
+            xmlChar *attributeValue = encodeString(attributeEntry.second, encoding);
+            status = xmlTextWriterWriteAttribute(writer, BAD_CAST attributeName, BAD_CAST attributeValue);
+            if (attributeValue) {
+                xmlFree(attributeValue);
+            }
+            if (attributeName) {
+                xmlFree(attributeName);
+            }
+            if (status < 0) {
+                throw std::runtime_error("Error at xmlTextWriterWriteAttribute");
+            }
+        }
+
+        // Write option value
+        xmlChar *elementText = encodeString(option.value, encoding);
+        status = xmlTextWriterWriteFormatString(writer, "%s", BAD_CAST elementText);
         if (elementText) {
             xmlFree(elementText);
         }
-        if (elementName) {
-            xmlFree(elementName);
+        if (status < 0) {
+            throw std::runtime_error("Error at xmlTextWriterStartElement");
         }
+
+        // End option
+        status = xmlTextWriterEndElement(writer);
         if (status < 0) {
-            throw std::runtime_error("Error at xmlTextWriterWriteFormatElement");
+            throw std::runtime_error("Error at xmlTextWriterEndElement");
         }
     }
 
diff --git a/src/IO/configuration_config.cpp b/src/IO/configuration_config.cpp
index 44a6cf3683..a9fd834b85 100644
--- a/src/IO/configuration_config.cpp
+++ b/src/IO/configuration_config.cpp
@@ -133,58 +133,226 @@ const Config::Options & Config::getOptions() const
 }
 
 /*!
-    Checks if the specified option exists.
+    Gets a reference to the specified option.
 
     \param key is the name of the option
-    \result True is the option exists, false otherwise.
+    \result A reference to the specified option.
 */
-bool Config::hasOption(const std::string &key) const
+Config::Option & Config::getOption(const std::string &key)
 {
-    return (m_options->count(key) > 0);
+    return const_cast<Option &>(static_cast<const Config &>(*this).getOption(key));
+}
+
+/*!
+    Gets a constant reference to the specified option.
+
+    \param key is the name of the option
+    \result A constant reference to the specified option.
+*/
+const Config::Option & Config::getOption(const std::string &key) const
+{
+    return (*m_options).at(key);
 }
 
 /*!
-    Gets the specified option.
+    Gets the value of the specified option.
 
     If the option does not exists an exception is thrown.
 
     \param key is the name of the option
-    \result The specified option.
+    \result The value of the specified option.
 */
 const std::string & Config::get(const std::string &key) const
 {
-    return m_options->at(key);
+    return getOption(key).value;
 }
 
 /*!
-    Gets the specified option.
+    Gets the value of the specified option.
 
     If the option does not exists the fallback value is returned.
 
     \param key is the name of the option
     \param fallback is the value that will be returned if the specified
     options does not exist
-    \result The specified option or the fallback value if the specified
+    \result The value of the specified option or the fallback value if the
     options does not exist.
 */
 std::string Config::get(const std::string &key, const std::string &fallback) const
 {
     if (hasOption(key)) {
-        return get(key);
+        return getOption(key).value;
     } else {
         return fallback;
     }
 }
 
 /*!
-    Set the given option to the specified value
+    Set the value of the specified option.
+
+    If the option does not exists, a new option will be added.
 
     \param key is the name of the option
     \param value is the value of the option
 */
 void Config::set(const std::string &key, const std::string &value)
 {
-    (*m_options)[key] = value;
+    if (hasOption(key)) {
+        getOption(key).value = value;
+    } else {
+        addOption(key, value);
+    }
+}
+
+/*!
+    Gets the value of the specified option attribute.
+
+    If the option or the attribute does not exists, an exception is thrown.
+
+    \param key is the name of the option
+    \param name is the name of the attribute
+    \result The value of the specified attribute.
+*/
+std::string Config::getAttribute(const std::string &key, const std::string &name) const
+{
+    return getOption(key).attributes.at(name);
+}
+
+/*!
+    Gets the value of the specified option attribute.
+
+    If the option does not exists, an exception will be thrown. However, if
+    the attribute do not exists, the fallback walue will be returned
+
+    \param key is the name of the option
+    \param name is the name of the attribute
+    \param fallback is the value that will be returned if the specified
+    attribute does not exist
+    \result The value of the specified attribute or the fallback value if
+    the options or the attribute does not exist.
+*/
+std::string Config::getAttribute(const std::string &key, const std::string &name, const std::string &fallback) const
+{
+    const Option &option = getOption(key);
+    if (option.attributes.count(name) > 0) {
+        return option.attributes.at(name);
+    }
+
+    return fallback;
+}
+
+/*!
+    Set the value of the specified option attribute.
+
+    If the option does not exists, an exception will be thrown. However,
+    if the attribute does not exists, a new attribute will be added.
+
+    \param key is the name of the option
+    \param name is the name of the attribute
+    \param value is the value of the attribute
+*/
+void Config::setAttribute(const std::string &key, const std::string &name, const std::string &value)
+{
+    getOption(key).attributes[name] = value;
+}
+
+/*!
+    Checks if the specified option exists.
+
+    \param key is the name of the option
+    \result True is the option exists, false otherwise.
+*/
+bool Config::hasOption(const std::string &key) const
+{
+    return (m_options->count(key) > 0);
+}
+
+/*!
+    Add an option to the configuration storage.
+
+    If an option with the same key already exists, it will be overwritten.
+
+    \param key is the name of the option
+    \param option is the option that will be added
+*/
+void Config::addOption(const std::string &key, const Option &option)
+{
+    (*m_options)[key] = option;
+}
+
+/*!
+    Add an option to the configuration storage.
+
+    If an option with the same key already exists, it will be overwritten.
+
+    \param key is the name of the option
+    \param option is the option that will be added
+*/
+void Config::addOption(const std::string &key, Option &&option)
+{
+    (*m_options)[key] = std::move(option);
+}
+
+/*!
+    Add an option to the configuration storage.
+
+    If an option with the same key already exists, it will be overwritten.
+
+    \param key is the name of the option
+    \param value is the value of the option
+*/
+void Config::addOption(const std::string &key, const std::string &value)
+{
+    addOption(key, std::string(value), Attributes());
+}
+
+/*!
+    Add an option to the configuration storage.
+
+    If an option with the same key already exists, it will be overwritten.
+
+    \param key is the name of the option
+    \param value is the value of the option
+*/
+void Config::addOption(const std::string &key, std::string &&value)
+{
+    addOption(key, std::move(value), Attributes());
+}
+
+/*!
+    Add an option to the configuration storage.
+
+    If an option with the same key already exists, it will be overwritten.
+
+    \param key is the name of the option
+    \param value is the value of the option
+    \param attributes are the attributes of the option
+*/
+void Config::addOption(const std::string &key, const std::string &value, const Attributes &attributes)
+{
+    Option option;
+    option.value = value;
+    option.attributes = attributes;
+
+    addOption(key, std::move(option));
+}
+
+/*!
+    Add an option to the configuration storage.
+
+    If an option with the same key already exists, it will be overwritten.
+
+    \param key is the name of the option
+    \param value is the value of the option
+    \param attributes are the attributes of the option
+*/
+void Config::addOption(const std::string &key, std::string &&value, Attributes &&attributes)
+{
+    Option option;
+    option.value = std::move(value);
+    option.attributes = std::move(attributes);
+
+    addOption(key, std::move(option));
 }
 
 /*!
@@ -402,7 +570,23 @@ void Config::dump(std::ostream &out, int indentLevel) const
     out << indent << "Options..." << std::endl;
     if (getOptionCount() > 0) {
         for (const auto &entry : getOptions()) {
-            out << indent << padding << entry.first << " = " << entry.second << std::endl;
+            const std::string &key = entry.first;
+            const Option &option = entry.second;
+
+            // Option value
+            out << indent << padding << key << " = " << option.value << std::endl;
+
+            // Option attributes
+            if (!option.attributes.empty()) {
+                for (const auto &attributeEntry : option.attributes) {
+                    const std::string &name = attributeEntry.first;
+                    const std::string &value = attributeEntry.second;
+
+                    out << indent << padding << padding << "Attribute: " << name << " = " << value << std::endl;
+                }
+            } else {
+                out << indent << padding << padding << "Option has not attributes." << std::endl;
+            }
         }
     } else {
         out << indent << padding << "No options." << std::endl;
diff --git a/src/IO/configuration_config.hpp b/src/IO/configuration_config.hpp
index ea923f6b5c..9039a76440 100644
--- a/src/IO/configuration_config.hpp
+++ b/src/IO/configuration_config.hpp
@@ -26,6 +26,7 @@
 
 #include <memory>
 #include <map>
+#include <string>
 #include <vector>
 
 namespace bitpit {
@@ -35,10 +36,18 @@ class Config
 {
 
 public:
+    typedef std::map<std::string, std::string> Attributes;
+
+    struct Option {
+        std::string value;
+        Attributes attributes;
+    };
+
+    typedef std::map<std::string, Option> Options;
+
     typedef Config Section;
     typedef std::vector<Section *> MultiSection;
     typedef std::vector<const Section *> ConstMultiSection;
-    typedef std::map<std::string, std::string> Options;
     typedef std::multimap<std::string, std::unique_ptr<Config>> Sections;
 
     Config(bool multiSections = false);
@@ -54,13 +63,26 @@ class Config
 
     bool isMultiSectionsEnabled() const;
 
+    const std::string & get(const std::string &key) const;
+    std::string get(const std::string &key, const std::string &fallback) const;
+    void set(const std::string &key, const std::string &value);
+
+    std::string getAttribute(const std::string &key, const std::string &name) const;
+    std::string getAttribute(const std::string &key, const std::string &name, const std::string &fallback) const;
+    void setAttribute(const std::string &key, const std::string &name, const std::string &value);
+
     int getOptionCount() const;
     Options & getOptions();
     const Options & getOptions() const;
+    Option & getOption(const std::string &key);
+    const Option & getOption(const std::string &key) const;
     bool hasOption(const std::string &key) const;
-    const std::string & get(const std::string &key) const;
-    std::string get(const std::string &key, const std::string &fallback) const;
-    void set(const std::string &key, const std::string &value);
+    void addOption(const std::string &key, const Option &option);
+    void addOption(const std::string &key, Option &&option);
+    void addOption(const std::string &key, const std::string &value);
+    void addOption(const std::string &key, std::string &&value);
+    void addOption(const std::string &key, const std::string &value, const Attributes &attributes);
+    void addOption(const std::string &key, std::string &&value, Attributes &&attributes);
     bool removeOption(const std::string &key);
 
     int getSectionCount() const;
@@ -91,6 +113,15 @@ class Config
     template<typename T>
     void set(const std::string &key, const T &value);
 
+    template<typename T>
+    T getAttribute(const std::string &key, const std::string &name) const;
+
+    template<typename T>
+    T getAttribute(const std::string &key, const std::string &name, const T &fallback) const;
+
+    template<typename T>
+    void setAttribute(const std::string &key, const std::string &name, const T &value);
+
 protected:
     bool m_multiSections;
 
diff --git a/src/IO/configuration_config.tpp b/src/IO/configuration_config.tpp
index 33413428ac..c101c4f80e 100644
--- a/src/IO/configuration_config.tpp
+++ b/src/IO/configuration_config.tpp
@@ -41,7 +41,7 @@ template<typename T>
 T Config::get(const std::string &key) const
 {
     T value;
-    if (std::istringstream(get(key)) >> value) {
+    if (std::istringstream(getOption(key).value) >> value) {
         return value;
     } else {
         throw std::runtime_error("Unable to convert the option \"" + key + "\"");
@@ -80,7 +80,72 @@ void Config::set(const std::string &key, const T &value)
 {
     std::ostringstream valueStream;
     if (valueStream << value) {
-        set(key, valueStream.str());
+        getOption(key).value = valueStream.str();
+    } else {
+        throw std::runtime_error("Unable to convert the option \"" + key + "\"");
+    }
+}
+
+/*!
+    Gets the value of the specified option attribute.
+
+    If the option or the attribute does not exists, an exception is thrown.
+
+    \param key is the name of the option
+    \param name is the name of the attribute
+    \result The value of the specified attribute.
+*/
+template<typename T>
+T Config::getAttribute(const std::string &key, const std::string &name) const
+{
+    T value;
+    if (std::istringstream(getOption(key).attributes.at(name)) >> value) {
+        return value;
+    } else {
+        throw std::runtime_error("Unable to convert the option \"" + key + "\"");
+    }
+}
+
+/*!
+    Gets the value of the specified option attribute.
+
+    If the option does not exists, an exception will be thrown. However, if
+    the attribute do not exists, the fallback walue will be returned
+
+    \param key is the name of the option
+    \param name is the name of the attribute
+    \param fallback is the value that will be returned if the specified
+    attribute does not exist
+    \result The value of the specified attribute or the fallback value if
+    the options or the attribute does not exist.
+*/
+template<typename T>
+T Config::getAttribute(const std::string &key, const std::string &name, const T &fallback) const
+{
+    const Option &option = getOption(key);
+    if (option.attributes.count(name) > 0) {
+        return getAttribute<T>(key);
+    }
+
+    return fallback;
+}
+
+/*!
+    Set the value of the specified option attribute.
+
+    If the option does not exists, an exception will be thrown. However,
+    if the attribute does not exists, a new attribute will be added.
+
+    \param key is the name of the option
+    \param name is the name of the attribute
+    \param value is the value of the attribute
+*/
+template<typename T>
+void Config::setAttribute(const std::string &key, const std::string &name, const T &value)
+{
+    std::ostringstream valueStream;
+    if (valueStream << value) {
+        getOption(key).attributes[name] = valueStream.str();
     } else {
         throw std::runtime_error("Unable to convert the option \"" + key + "\"");
     }
diff --git a/test/integration_tests/IO/data/configuration.xml b/test/integration_tests/IO/data/configuration.xml
index 8bc26f5a42..935352c13a 100644
--- a/test/integration_tests/IO/data/configuration.xml
+++ b/test/integration_tests/IO/data/configuration.xml
@@ -2,18 +2,18 @@
 <bitpit version="1">
     <first>
         <color>blue</color>
-        <distance>11</distance>
+        <distance unit="km" type="offroad">11</distance>
         <exists>1</exists>
         <data>
-            <x>11.11</x>
+            <x min="0" max="100">11.11</x>
         </data>
     </first>
     <second>
         <color>red</color>
-        <distance>22</distance>
+        <distance unit="mi" type="urban">22</distance>
         <exists>0</exists>
         <data>
-            <y>22.22</y>
+            <y min="20" max="200">22.22</y>
         </data>
     </second>
-</bitpit>
\ No newline at end of file
+</bitpit>
diff --git a/test/integration_tests/IO/test_IO_00004.cpp b/test/integration_tests/IO/test_IO_00004.cpp
index 4a55e05c43..4171d12be0 100644
--- a/test/integration_tests/IO/test_IO_00004.cpp
+++ b/test/integration_tests/IO/test_IO_00004.cpp
@@ -59,8 +59,8 @@ int subtest_001()
     std::cout << "Access configuration..." << std::endl;
     std::cout << "  - Section \"first\" has color..." << config::root["first"].get("color") << std::endl;
     std::cout << "  - Section \"second\" has color..." << config::root["second"].get("color") << std::endl;
-    std::cout << "  - Section \"first\" has distance..." << config::root.getSection("first").get("distance") << std::endl;
-    std::cout << "  - Section \"second\" has y data..." << config::root["second"]["data"].get("y") << std::endl;
+    std::cout << "  - Section \"first\" has distance..." << config::root.getSection("first").get("distance") << " " << config::root.getSection("first").getAttribute("distance", "unit") << std::endl;
+    std::cout << "  - Section \"second\" has y data..." << config::root["second"]["data"].get("y") << " " << config::root.getSection("second").getSection("data").getAttribute("y", "unit", "kg") << std::endl;
     std::cout << "  - Section \"first\" option count..." << config::root.getSection("first").getOptionCount() << std::endl;
     std::cout << "  - Section \"first\" sub-section count..." << config::root.getSection("first").getSectionCount() << std::endl;
 
@@ -68,10 +68,16 @@ int subtest_001()
     std::cout << "  - Section \"first\" has distance (int)..." << firstDistanceInt << std::endl;
 
     double firstDistanceDouble = config::root["first"].get<double>("distance");
-    std::cout << "  - Section \"first\" has distance (double)..." << firstDistanceDouble << std::endl;
+    std::cout << "  - Section \"first\" has distance (double)..." << firstDistanceDouble << " " << config::root.getSection("first").getOption("distance").attributes["unit"] << std::endl;
 
     double secondDataDouble = config::root["second"]["data"].get<double>("y");
-    std::cout << "  - Section \"section\" has y data (double)..." << secondDataDouble << std::endl;
+    std::cout << "  - Section \"section\" has y data (double)..." << secondDataDouble << " " << config::root["second"]["data"].getAttribute("y", "unit", "kg") << std::endl;
+
+    double secondMinDataDouble = config::root["second"]["data"].getAttribute<double>("y", "min");
+    std::cout << "  - Section \"section\" has y min value (double)..." << secondMinDataDouble << std::endl;
+
+    double secondMaxDataDouble = config::root["second"]["data"].getAttribute<double>("y", "max");
+    std::cout << "  - Section \"section\" has y max value (double)..." << secondMaxDataDouble << std::endl;
 
     bool firstExistsBool = config::root["first"].get<bool>("exists");
     std::cout << "  - Section \"first\" has distance..." << firstExistsBool << std::endl;
@@ -88,12 +94,16 @@ int subtest_001()
     config::root["second"].set("color", "orange");
 
     config::root["first"].set("distance", 111);
-    config::root["second"].set("distance", 222);
+    config::root["first"].setAttribute("distance", "unit", "mi");
+    config::root["second"].getOption("distance").value = "111";
+    config::root["second"].getOption("distance").attributes["unit"] = "km";
 
     config::root["first"].set("exists", true);
     config::root["second"].set("exists", true);
 
+    config::root["first"]["data"].setAttribute("x", "max", 150);
     config::root["first"]["data"].set("x", 111.111);
+    config::root["second"]["data"].setAttribute("y", "max", 250);
     config::root["second"]["data"].set("y", 222.222);
 
     // Dump the configuration

From 720e1cc09d6e5d9ff3fa45bb2a796cfa3b5cc10a Mon Sep 17 00:00:00 2001
From: Andrea Iob <andrea_iob@hotmail.com>
Date: Wed, 9 Feb 2022 21:33:06 +0100
Subject: [PATCH 2/2] IO/config: return constant references whenever possible

---
 src/IO/configuration_config.cpp | 2 +-
 src/IO/configuration_config.hpp | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/IO/configuration_config.cpp b/src/IO/configuration_config.cpp
index a9fd834b85..f4922672f7 100644
--- a/src/IO/configuration_config.cpp
+++ b/src/IO/configuration_config.cpp
@@ -213,7 +213,7 @@ void Config::set(const std::string &key, const std::string &value)
     \param name is the name of the attribute
     \result The value of the specified attribute.
 */
-std::string Config::getAttribute(const std::string &key, const std::string &name) const
+const std::string & Config::getAttribute(const std::string &key, const std::string &name) const
 {
     return getOption(key).attributes.at(name);
 }
diff --git a/src/IO/configuration_config.hpp b/src/IO/configuration_config.hpp
index 9039a76440..a0e18a02be 100644
--- a/src/IO/configuration_config.hpp
+++ b/src/IO/configuration_config.hpp
@@ -67,7 +67,7 @@ class Config
     std::string get(const std::string &key, const std::string &fallback) const;
     void set(const std::string &key, const std::string &value);
 
-    std::string getAttribute(const std::string &key, const std::string &name) const;
+    const std::string & getAttribute(const std::string &key, const std::string &name) const;
     std::string getAttribute(const std::string &key, const std::string &name, const std::string &fallback) const;
     void setAttribute(const std::string &key, const std::string &name, const std::string &value);