Finish v0.1.0

This is the initial release including all necessary basic features.

Author: Master92

.gitignore

@@ -2,3 +2,4 @@
 /*build*
 /doc
 /include/cppIni/cppini_export.h
+CMakeUserPresets.json

CMakeLists.txt

@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.24)
-project(cppIni LANGUAGES CXX VERSION 0.0.0)
+project(cppIni LANGUAGES CXX VERSION 0.1.0)
 
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)

README.md

@@ -1,6 +1,7 @@
-# cppIni - A C++20/23 library for reading and writing INI files
+# cppIni - A C++20 library for reading and writing INI files
 
-[![Build](https://github.com/Master92/cppIni/actions/workflows/build.yaml/badge.svg)](https://github.com/Master92/cppIni/actions/workflows/build.yaml)
+[![Release](https://img.shields.io/github/v/tag/Master92/cppIni?label=release)](https://github.com/Master92/cppIni/releases)
+[![Build](https://img.shields.io/github/actions/workflow/status/Master92/cppIni/build.yaml?logo=github)](https://github.com/Master92/cppIni/actions/workflows/build.yaml)
 ![License](https://img.shields.io/github/license/Master92/cppIni)
 ![GitHub stars](https://img.shields.io/github/stars/Master92/cppIni?label=%E2%AD%90%20Stars)
 
@@ -9,12 +10,44 @@
 This project is a library for reading and writing INI files. It is written in C++20 and uses the STL.
 It is tested with GCC 13, Clang 16 and MSVC 19.36. It should work with any compiler that supports C++20.
 
+### Reading and manipulating INI files
+
+The library is able to read INI files and parses them automatically. It is able to read the following types:
+
+- `bool`              
+- `char`              
+- `short`             
+- `int`               
+- `long`              
+- `long long`         
+- `unsigned char`     
+- `unsigned short`    
+- `unsigned int`      
+- `unsigned long`     
+- `unsigned long long`
+- `float`             
+- `double`            
+- `long double`       
+- `std::string`       
+- `std::string_view`  
+- `const char*`
+
+Accessing a value is done with the `get` template-function. It takes the section and the key as parameters and returns
+the value as the specified type `T`. If the value does not exist, the default value (`T()`) is returned.
+
+Setting a value is done with the `set` template-function. It takes the section, the key and the value as parameters.
+The value is converted to a string and written to the file. If the section or the key does not exist, it is created.
+On every write, the file is completely rewritten.
+
 ## Usage
 
 ``` cpp  
 #include <cppIni/cppIni.hpp>
 
-Inifile ini("test.ini");
+File ini("test.ini");
+const auto intValue = init.get<int>("section", "key");
+const auto newValue = 42;
+ini.set("section", "key", newValue);
 ```
 
 ## License

include/cppIni/Entry.h

@@ -1,5 +1,5 @@
 /*
- * cppIni - C++20/23 library for dealing with settings files
+ * cppIni - A C++20 library for reading and writing INI files
  * Copyright (C) 2023 Nils Hofmann <nils.friedchen@googlemail.com>
  *
  * This program is free software: you can redistribute it and/or modify
@@ -40,11 +40,10 @@ class CPPINI_EXPORT Entry {
     constexpr Entry(std::string_view key, T value, Section* parent = nullptr); ///< Constructor with key, value and parent Section pointer (default nullptr)
 
     auto key() const -> std::string_view { return m_key; } ///< Key as std::string_view
-
+    auto fqKey() const -> std::string; ///< Fully qualified key (e.g. "Section1.Section2.Key")
     template<class T> auto value() const -> T; ///< Value as type T
     auto data() const -> std::string_view { return m_data; } ///< Value as std::string_view
     constexpr auto parent() const -> const Section* { return m_parent; } ///< Parent Section
-    auto fqKey() const -> std::string; ///< Fully qualified key (e.g. "Section1.Section2.Key")
 
     auto setKey(std::string_view key) -> void { m_key = key; } ///< Set the key
     template<class T> auto setData(T value) -> void; ///< Set the value
@@ -56,6 +55,10 @@ class CPPINI_EXPORT Entry {
     auto operator=(const Entry& other) -> Entry& = default; ///< Copy assignment operator
     auto operator=(Entry&& other) -> Entry& = default; ///< Move assignment operator
 
+    template<class T>
+    requires (not std::is_same_v<T, Entry>)
+    auto operator=(T value) -> Entry& { setData(value); return *this; } ///< Assignment operator for setting the value
+
 private:
     std::string m_key {};
     std::string m_data {};
@@ -112,6 +115,7 @@ inline auto Entry::setData(std::string_view value) -> void
     m_data = value;
 }
 
+template<> inline auto Entry::value<bool>() const               -> bool               { return std::stoi(m_data); }
 template<> inline auto Entry::value<char>() const               -> char               { return std::stoi(m_data); }
 template<> inline auto Entry::value<short>() const              -> short              { return std::stoi(m_data); }
 template<> inline auto Entry::value<int>() const                -> int                { return std::stoi(m_data); }

include/cppIni/File.h

@@ -1,5 +1,5 @@
 /*
- * cppIni - C++20/23 library for dealing with settings files
+ * cppIni - A C++20 library for reading and writing INI files
  * Copyright (C) 2023 Nils Hofmann <nils.friedchen@googlemail.com>
  *
  * This program is free software: you can redistribute it and/or modify
@@ -23,30 +23,68 @@
 
 #include <filesystem>
 #include <vector>
+#include <format>
 
 /// \brief Represents a file on disk.
 /// A file is a collection of Sections.
 class CPPINI_EXPORT File {
 public:
     explicit File(std::string_view filename); ///< Constructor.
-    virtual ~File() = default; ///< Destructor.
+    virtual ~File(); ///< Destructor.
 
     static File open(std::string_view filename); ///< Open a file. Throws if the file cannot be opened.
     void open(); ///< Open the file. Throws if the file cannot be opened.
+    void flush(); ///< Write the file to disk.
 
+    template<class T>
+    auto set(std::string_view section, std::string_view key, T value) -> void; ///< Set a value in a section.
+
+    auto getSection(std::string_view fqTitle) -> Section*; ///< Get a Section by fully qualified title (e.g. "Section1.Section2")
     auto findSection(std::string_view title) const -> const Section*; ///< Find a Section by title.
     auto findEntry(std::string_view name) const -> const Entry*; ///< Find an Entry by name.
 
+    template<class T>
+    auto get(std::string_view section, std::string_view name) const -> T; ///< Get an Entry by name and convert it to the specified type.
+
     constexpr auto sections() const -> const auto& { return m_sections; }
 
-    auto operator==(const File& other) const -> bool = default; ///< Equality operator.
-    auto operator!=(const File& other) const -> bool = default; ///< Inequality operator.
+    auto operator==(const File& other) const -> bool; ///< Equality operator.
+    auto operator!=(const File& other) const -> bool { return !(*this == other); }; ///< Inequality operator.
 
 private:
     void parse(); ///< Parse the file.
 
 private:
     std::string m_filename{};
 
-    std::vector<Section> m_sections{};
+    std::vector<Section*> m_sections{};
 };
+
+template<class T>
+auto File::get(std::string_view section, std::string_view name) const -> T
+{
+    if (const auto entry = findEntry(std::format("{}.{}", section, name))) {
+        return entry->value<T>();
+    }
+
+    return T();
+}
+
+/// \details The parameters are forwarded to the Section::setEntry() method. The Section is created if it does not exist.
+/// \arg section The title of the Section to set the value in.
+/// \arg key The key of the Entry to set.
+/// \arg value The value of the Entry to set.
+template<class T>
+auto File::set(std::string_view section, std::string_view key, T value) -> void
+{
+    if (auto s = std::ranges::find_if(m_sections,
+                                      [section](const auto& s) { return s->fqTitle() == section; });
+            s != m_sections.end()) {
+        (*s)->setEntry({key, value});
+    } else {
+        auto targetSection = getSection(section);
+        targetSection->setEntry({key, value});
+    }
+
+    flush();
+}

include/cppIni/Section.h

@@ -1,5 +1,5 @@
 /*
- * cppIni - C++20/23 library for dealing with settings files
+ * cppIni - A C++20 library for reading and writing INI files
  * Copyright (C) 2023 Nils Hofmann <nils.friedchen@googlemail.com>
  *
  * This program is free software: you can redistribute it and/or modify
@@ -28,7 +28,7 @@
 /// \note A section has a title and a list of Entry objects
 class CPPINI_EXPORT Section {
 public:
-    explicit Section(std::string_view title, Section* parent = nullptr); ///< Constructor with title
+    explicit Section(std::string_view title, const Section* parent = nullptr); ///< Constructor with title
 
     auto title() const -> std::string_view { return m_title; } ///< Title as std::string_view
     auto fqTitle() const -> std::string; ///< Fully qualified title (e.g. "Section1.Section2")
@@ -37,6 +37,7 @@ class CPPINI_EXPORT Section {
     auto isSubsection() const -> bool { return m_parent != nullptr; } ///< Returns true if this Section is a subsection
 
     auto addEntry(Entry entry) -> void; ///< Add an Entry object to the section
+    auto setEntry(Entry entry) -> void; ///< Set an Entry object in the section and create it if it does not exist
 
     template<class T>
     auto createEntry(std::string_view key, T value) -> void; ///< Create an Entry object in place and add it to the section
@@ -50,7 +51,7 @@ class CPPINI_EXPORT Section {
 private:
     std::string m_title;
     std::unordered_map<std::string, Entry> m_entries;
-    Section *m_parent {nullptr};
+    const Section *m_parent {nullptr};
 };
 
 /// \details The parameters are forwarded to the Entry constructor and a pointer to this Section object is added as the parent

include/cppIni/cppIni.h

@@ -1,5 +1,5 @@
 /*
- * cppIni - C++20/23 library for dealing with settings files
+ * cppIni - A C++20 library for reading and writing INI files
  * Copyright (C) 2023 Nils Hofmann <nils.friedchen@googlemail.com>
  *
  * This program is free software: you can redistribute it and/or modify

src/Entry.cpp

@@ -1,5 +1,5 @@
 /*
- * cppIni - C++20/23 library for dealing with settings files
+ * cppIni - A C++20 library for reading and writing INI files
  * Copyright (C) 2023 Nils Hofmann <nils.friedchen@googlemail.com>
  *
  * This program is free software: you can redistribute it and/or modify

src/File.cpp

@@ -1,5 +1,5 @@
 /*
- * cppIni - C++20/23 library for dealing with settings files
+ * cppIni - A C++20 library for reading and writing INI files
  * Copyright (C) 2023 Nils Hofmann <nils.friedchen@googlemail.com>
  *
  * This program is free software: you can redistribute it and/or modify
@@ -18,6 +18,7 @@
 
 #include <cppIni/File.h>
 
+#include <algorithm>
 #include <fstream>
 #include <stdexcept>
 
@@ -28,6 +29,15 @@ File::File(std::string_view filename)
     open();
 }
 
+File::~File()
+{
+    for (auto& section : m_sections) {
+        delete section;
+    }
+
+    m_sections.clear();
+}
+
 /// \param filename The filename of the file to open.
 File File::open(std::string_view filename)
 {
@@ -44,17 +54,53 @@ void File::open()
     parse();
 }
 
+void File::flush()
+{
+    std::ofstream file{m_filename};
+
+    for (const auto& section: m_sections) {
+        file << std::format("[{}]\n", section->fqTitle());
+
+        for (const auto& [_, entry]: section->entries()) {
+            file << std::format("{}={}\n", entry.key(), entry.data());
+        }
+
+        file << "\n";
+    }
+}
+
+/// \details Scans the vector of Sections for the parent and creates the tree including the new Section if it does not exist.
+/// \param fqTitle The fully qualified title of the Section to create.
+/// \returns A pointer to the created Section.
+auto File::getSection(std::string_view fqTitle) -> Section*
+{
+    if (const auto section = findSection(fqTitle); section) {
+        return const_cast<Section*>(section);
+    }
+
+    if (fqTitle.find('.') == std::string_view::npos) {
+        m_sections.emplace_back(new Section(fqTitle));
+        return m_sections.back();
+    } else {
+        const auto parent = getSection(fqTitle.substr(0, fqTitle.find_last_of('.')));
+        m_sections.emplace_back(new Section(fqTitle.substr(fqTitle.find_last_of('.') + 1), parent));
+        return m_sections.back();
+    }
+}
+
 /// \param title The title of the Section to find.
 /// \returns A pointer to the Section if found, nullptr otherwise.
 auto File::findSection(std::string_view title) const -> const Section*
 {
-    for (const auto& section : m_sections) {
-        if (section.fqTitle() == title) {
-            return &section;
-        }
+    const auto section = std::find_if(std::cbegin(m_sections), std::cend(m_sections), [&title](const auto& section) {
+        return section->fqTitle() == title;
+    });
+
+    if (section == std::cend(m_sections)) {
+        return nullptr;
     }
 
-    return nullptr;
+    return *section;
 }
 
 /// \param name The name of the Entry to find.
@@ -75,6 +121,13 @@ auto File::findEntry(std::string_view name) const -> const Entry*
     return nullptr;
 }
 
+auto File::operator==(const File& other) const -> bool
+{
+    return std::equal(std::cbegin(m_sections), std::cend(m_sections), std::cbegin(other.m_sections), std::cend(other.m_sections), [](const auto& lhs, const auto& rhs) {
+        return *lhs == *rhs;
+    });
+}
+
 /// \details This function is called by the constructor. It should not be called directly.
 /// \throws std::runtime_error if the file cannot be opened.
 /// \see File::open for the public function.
@@ -83,20 +136,29 @@ auto File::parse() -> void
     auto content = std::ifstream{m_filename};
 
     for (std::string line; std::getline(content, line);) {
-        const std::string_view lineView{line};
+        std::string_view lineView{line};
 
         if (lineView.empty()) {
             continue;
         }
 
-        if (line[0] == '[') {
-            if (line.find('.') != std::string::npos) {
-                m_sections.emplace_back(lineView.substr(lineView.find_last_of('.') + 1, lineView.find_last_of(']') - 1), &m_sections.back());
-            } else {
-                m_sections.emplace_back(lineView.substr(1, lineView.find_last_of(']') - 1));
+        if (lineView[0] == '[') {
+            lineView = lineView.substr(1);
+
+            Section* parent = lineView.at(0) == '.' ? m_sections.back() : nullptr;
+
+            if (lineView[0] == '.') {
+                lineView = lineView.substr(1);
+            } else if (const auto section = std::find_if(std::begin(m_sections), std::end(m_sections), [&lineView](const auto& section) {
+                return section->fqTitle() == lineView.substr(0, lineView.find_last_of('.'));
+            }); section != std::end(m_sections)) {
+                parent = *section;
+                lineView = lineView.substr(lineView.find_last_of('.') + 1);
             }
+
+            m_sections.emplace_back(new Section(lineView.substr(0, lineView.find(']')), parent));
         } else {
-            m_sections.back().createEntry(lineView.substr(0, lineView.find('=')), lineView.substr(lineView.find('=') + 1));
+            m_sections.back()->createEntry(lineView.substr(0, lineView.find('=')), lineView.substr(lineView.find('=') + 1));
         }
     }
 }