INIpp 2/2

Author: Ohjurot

09_INIpp/INIpp.cpp

@@ -164,3 +164,8 @@ void INIpp::SAXParser::ParseKVPair(const std::string& section, const std::string
         m_callback(section, key, value);
     }
 }
+
+void INIpp::DOMParser::ParseKVPair(const std::string& section, const std::string& key, const std::string& value)
+{
+    m_document[section].Append(DOM::KVPair(key, value));
+}

09_INIpp/INIpp.hpp

@@ -3,14 +3,140 @@
 #include <string>
 #include <format>
 #include <cctype>
+#include <vector>
 #include <fstream>
+#include <sstream>
 #include <stdexcept>
 #include <functional>
 #include <filesystem>
 #include <string_view>
+#include <unordered_map>
 
 namespace INIpp
 {
+    namespace DOM
+    {
+        class KVPair
+        {
+            public:
+                KVPair() = default;
+                KVPair(const std::string_view& key, const std::string_view& value) :
+                    m_key(key), m_value(value)
+                {}
+
+                inline const std::string& Key() const noexcept
+                {
+                    return m_key;
+                }
+                inline const std::string& Value() const noexcept
+                {
+                    return m_value;
+                }
+
+                template<typename T>
+                T Get(const T& defaultValue = T())
+                {
+                    T temp = defaultValue;
+                    std::stringstream ss;
+                    ss << m_value;
+                    ss >> temp;
+                    return temp;
+                }
+
+                template<>
+                std::string Get(const std::string& defaultValue)
+                {
+                    return m_value;
+                }
+
+            private:
+                std::string m_key;
+                std::string m_value;
+        };
+
+        class Section
+        {
+            public:
+                using Key = std::string;
+
+                Section() = default;
+                Section(const std::string_view& name) : 
+                    m_name(name)
+                {}
+
+                inline const std::string& Name() const noexcept
+                {
+                    return m_name;
+                }
+
+                inline KVPair& operator[](const Key& key)
+                {
+                    return m_kvPairs.find(key)->second;
+                }
+                inline const KVPair& operator[](const Key& key) const
+                {
+                    return m_kvPairs.find(key)->second;
+                }
+
+                std::vector<Key> Keys() const
+                {
+                    std::vector<Key> keys;
+                    for (auto& pair : m_kvPairs)
+                    {
+                        keys.push_back(pair.first);
+                    }
+                    return keys;
+                }
+
+                void Append(KVPair&& value)
+                {
+                    m_kvPairs.emplace(value.Key(), std::move(value));
+                }
+
+            private:
+                std::string m_name;
+                std::unordered_map<Key, KVPair> m_kvPairs;
+        };
+
+        class Document
+        {
+            public:
+                using Key = std::string;
+
+                inline Section& operator[](const Key& name)
+                {
+                    // Existing section
+                    auto it = m_sections.find(name);
+                    if (it != m_sections.end())
+                    {
+                        return it->second;
+                    }
+
+                    // New section
+                    auto& section = m_sections[name];
+                    section = std::move(Section(name));
+                    return section;
+                }
+                inline const Section& operator[](const Key& name) const
+                {
+                    return m_sections.find(name)->second;
+                }
+
+                std::vector<Key> Sections() const
+                {
+                    std::vector<Key> sections;
+                    for (auto& section : m_sections)
+                    {
+                        sections.push_back(section.first);
+                    }
+                    return sections;
+                }
+
+            private:
+                std::unordered_map<Key, Section> m_sections;
+        };
+    }
+
     class Exception : public std::runtime_error
     {
         public:
@@ -73,7 +199,12 @@ namespace INIpp
         public:
             void ParseKVPair(const std::string& section, const std::string& key, const std::string& value) override;
 
-        private:
+            inline DOM::Document& Get()
+            {
+                return m_document;
+            }
 
+        private:
+            DOM::Document m_document;
     };
 }

09_INIpp/main.cpp

@@ -3,38 +3,12 @@
 #include <iostream>
 #include <sstream>
 
-class MyFancySettingsProvider
-{
-    public:
-        MyFancySettingsProvider(std::ostream& os) :
-            m_os(os)
-        {}
-
-        void Kickoff(const std::filesystem::path& configFile = "./config.ini")
-        {
-            INIpp::SAXParser parser(
-                std::bind(&MyFancySettingsProvider::OnKVPair, this, 
-                    std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
-            parser.AddFile(configFile);
-        }
-
-    private:
-        void OnKVPair(const std::string& s, const std::string& k, const std::string& v)
-        {
-            m_os << s << ": " << k << " = " << v << std::endl;
-        }
-
-    private:
-        std::ostream& m_os;
-};
-
 int main()
 {
-    std::stringstream ss;
+    INIpp::DOMParser parser;
+    parser.AddFile("./config.ini");
 
-    MyFancySettingsProvider sp(ss);
-    sp.Kickoff();
-    
-    std::ofstream of("./myfile.ini");
-    of << ss.str();
+    INIpp::DOM::Document doc = parser.Get();
+    auto port = doc["owner"]["name"].Get<std::string>();
+    std::cout << "Port: " << port;
 }