ConfigurationBag.h

Go to the documentation of this file.

 
#pragma once
#include "ConfigurationValueParsers.h"
#include "catapult/exceptions.h"
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
namespace catapult { namespace utils {
 
    class VISIBLE_EXCEPTION_ATTRIBUTE property_not_found_error : public catapult_invalid_argument {
    public:
        using catapult_invalid_argument::catapult_invalid_argument;
    };
 
    class VISIBLE_EXCEPTION_ATTRIBUTE property_malformed_error : public catapult_runtime_error {
    public:
        using catapult_runtime_error::catapult_runtime_error;
    };
 
    struct ConfigurationKey {
        constexpr ConfigurationKey(const char* section, const char* name) : Section(section), Name(name)
        {}
 
        const char* Section;
 
        const char* Name;
    };
 
    class ConfigurationBag {
    public:
        template<typename TValue>
        using OrderedKeyValueMap = std::vector<std::pair<std::string, TValue>>;
 
        template<typename TValue>
        using UnorderedKeyValueMap = std::unordered_map<std::string, TValue>;
 
        using ValuesContainer = std::unordered_map<std::string, OrderedKeyValueMap<std::string>>;
 
    public:
        ConfigurationBag(ValuesContainer&& values) : m_values(values)
        {}
 
    public:
        static ConfigurationBag FromStream(std::istream& input);
 
        static ConfigurationBag FromPath(const std::string& path);
 
    public:
        size_t size() const {
            size_t count = 0;
            for (const auto& section : m_values)
                count += section.second.size();
 
            return count;
        }
 
        size_t size(const char* section) const {
            auto sectionIter = m_values.find(section);
            return m_values.cend() == sectionIter ? 0 : sectionIter->second.size();
        }
 
        bool contains(const ConfigurationKey& key) const {
            return !!lookup(key);
        }
 
        std::unordered_set<std::string> sections() const {
            std::unordered_set<std::string> sections;
            for (const auto& pair : m_values)
                sections.insert(pair.first);
 
            return sections;
        }
 
        template<typename T>
        bool tryGet(const ConfigurationKey& key, T& value) const {
            auto pUnparsedValue = lookup(key);
            if (!pUnparsedValue)
                return false;
 
            if (!TryParseValue(*pUnparsedValue, value)) {
                auto message = "property could not be parsed";
                CATAPULT_THROW_AND_LOG_2(property_malformed_error, message, std::string(key.Section), std::string(key.Name));
            }
 
            return true;
        }
 
        template<typename T>
        T get(const ConfigurationKey& key) const {
            T value;
            if (!tryGet(key, value)) {
                auto message = "property not found";
                CATAPULT_THROW_AND_LOG_2(property_not_found_error, message, std::string(key.Section), std::string(key.Name));
            }
 
            return value;
        }
 
        template<typename T>
        UnorderedKeyValueMap<T> getAll(const char* section) const {
            auto values = getAllOrdered<T>(section);
 
            UnorderedKeyValueMap<T> unorderedValues;
            for (const auto& value : values)
                unorderedValues.emplace(value);
 
            return unorderedValues;
        }
 
        template<typename T>
        OrderedKeyValueMap<T> getAllOrdered(const char* section) const {
            OrderedKeyValueMap<T> values;
 
            auto sectionIter = m_values.find(section);
            if (m_values.cend() == sectionIter)
                return values;
 
            for (const auto& pair : sectionIter->second)
                values.emplace_back(pair.first, get<T>(ConfigurationKey(section, pair.first.c_str())));
 
            return values;
        }
 
    private:
        const std::string* lookup(const ConfigurationKey& key) const {
            auto sectionIter = m_values.find(key.Section);
            if (m_values.cend() == sectionIter)
                return nullptr;
 
            const auto& sectionValues = sectionIter->second;
            auto itemIter = std::find_if(sectionValues.cbegin(), sectionValues.cend(), [&name = key.Name](const auto& pair) {
                return name == pair.first;
            });
 
            if (sectionValues.cend() == itemIter)
                return nullptr;
 
            return &itemIter->second;
        }
 
    private:
        ValuesContainer m_values;
    };
}}