ini.hh

#ifndef VTESTBED_INI_INI_HH
#define VTESTBED_INI_INI_HH

#include <locale>
#include <map>
#include <sstream>
#include <vector>

#include <vtestbed/ini/types.hh>

namespace vtb {

    namespace ini {

        class Ini {

        private:

            using map_1d = std::map<std::string,std::string>;
            using map_2d = std::map<std::string,map_1d>;

            enum Read_State {
                READ_STATE_NONE,
                READ_STATE_CATEGORY,
                READ_STATE_POST_CATEGORY,
                READ_STATE_COMMENT,
                READ_STATE_PRE_KEY,
                READ_STATE_KEY,
                READ_STATE_VALUE,
            };

        private:
            map_2d _categories;
            bool _has_changes = false;

        public:

            int load(const string_type& filename, bool keep_existing = false);
            bool save(const string_type& filename);
            inline bool HasChanges() const { return this->_has_changes; }
            inline const map_2d& sections() const { return this->_categories; }
            bool HasCategory(const string_type& category) const;

            template <class T>
            T find(const char* category, const char* key) const {
                auto r1 = this->_categories.find(category);
                if (r1 == this->_categories.end()) {
                    throw std::invalid_argument(key);
                }
                auto r2 = r1->second.find(key);
                if (r2 == r1->second.end()) {
                    throw std::invalid_argument(key);
                }
                T value{};
                std::istringstream in(r2->second);
                in.imbue(std::locale::classic());
                if (!(in >> value)) {
                    throw std::invalid_argument(key);
                }
                return value;
            }

            template <class T>
            T get(
                const string_type& category,
                const string_type& key,
                T def_value
            ) const {
                auto r1 = this->_categories.find(category);
                if (r1 == this->_categories.end()) { return def_value; }
                auto r2 = r1->second.find(key);
                if (r2 == r1->second.end()) { return def_value; }
                T value{};
                std::istringstream in(r2->second);
                in.imbue(std::locale::classic());
                if (in >> value) { return value; }
                return def_value;
            }

            inline string_type
            get(
                const char* category,
                const char* key,
                const char* def_value = ""
            ) const {
                return this->get<string_type>(category, key, def_value);
            }

            template <class T>
            void set(const char* category, const char* key, T value) {
                std::ostringstream out;
                out.imbue(std::locale::classic());
                out << value;
                this->_categories[category][key] = out.str();
                this->_has_changes = true;
            }

            inline void
            set(const char* category, const char* key, const char* value) {
                this->_categories[category][key] = value;
                this->_has_changes = true;
            }

            inline void
            set(const char* category, const char* key, const string_type& value) {
                this->_categories[category][key] = value;
                this->_has_changes = true;
            }

        };
    }
}

#endif // vim:filetype=cpp