ConfigurationParser.h

Go to the documentation of this file.

/*
 * Copyright Onix Solutions Limited [OnixS]. All rights reserved.
 *
 * This software owned by Onix Solutions Limited [OnixS] and is protected by copyright law
 * and international copyright treaties.
 *
 * Access to and use of the software is governed by the terms of the applicable OnixS Software
 * Services Agreement (the Agreement) and Customer end user license agreements granting
 * a non-assignable, non-transferable and non-exclusive license to use the software
 * for it's own data processing purposes under the terms defined in the Agreement.
 *
 * Except as otherwise granted within the terms of the Agreement, copying or reproduction of any part
 * of this source code or associated reference material to any other location for further reproduction
 * or redistribution, and any amendments to this copyright notice, are expressly prohibited.
 *
 * Any reproduction or redistribution for sale or hiring of the Software not in accordance with
 * the terms of the Agreement is a violation of copyright law.
 */
#pragma once
 
#include <OnixS/ICE/BOE/ABI.h>
 
#include <unordered_map>
#include <functional>
#include <string>
#include <stdexcept>
 
ONIXS_ICEBOE_NAMESPACE_BEGIN
 
namespace System {
namespace ConfigurationParser {
namespace Utils {
 
ONIXS_ICEBOE_EXPORTED
bool isEquals(const std::string& s1, const std::string& s2);
 
ONIXS_ICEBOE_EXPORTED
bool parse(uint64_t& result, const std::string& value);
 
ONIXS_ICEBOE_EXPORTED
bool parse(int64_t& result, const std::string& value);
 
ONIXS_ICEBOE_EXPORTED
bool parse(double& result, const std::string& value);
 
ONIXS_ICEBOE_EXPORTED
bool parse(bool& result, const std::string& value);
 
template<typename> struct NumberName { static const char * name() noexcept;};
 
#define ONIXS_TYPENAME(Type) template<> inline const char * NumberName<Type>::name() noexcept { return #Type; }
ONIXS_TYPENAME(uint8_t);
ONIXS_TYPENAME(int8_t);
ONIXS_TYPENAME(uint16_t);
ONIXS_TYPENAME(int16_t);
ONIXS_TYPENAME(uint32_t);
ONIXS_TYPENAME(int32_t);
ONIXS_TYPENAME(uint64_t);
ONIXS_TYPENAME(int64_t);
ONIXS_TYPENAME(double);
#undef ONIXS_TYPENAME
 
template<typename T>
T parse(const std::string& value)
{
    static_assert(std::is_arithmetic<T>::value, "");
 
    using Wide = typename std::conditional<std::is_floating_point<T>::value, double, typename std::conditional<std::is_signed<T>::value, int64_t, uint64_t>::type>::type;
 
    Wide v{};
 
    if(!parse(v, value) || static_cast<Wide>(static_cast<T>(v)) != v)
        throw std::invalid_argument("Cannot parse " + std::string(NumberName<T>::name()) + " value: '" + value + "'");
 
    return static_cast<T>(v);
}
 
template<typename T>
T fromString(const std::string& value)
{
    return parse<T>(value);
}
 
template<> inline std::string fromString<std::string>(const std::string& value)
{
    return value;
}
 
template<> inline bool fromString<bool>(const std::string& value)
{
    bool v{};
 
    if(!parse(v, value))
        throw std::invalid_argument("Cannot parse bool value: '" + value + "'");
 
    return v;
}
 
} // Utils
 
using KeyValueMap = std::unordered_map<std::string, std::string>;

ONIXS_ICEBOE_EXPORTED
KeyValueMap parseConfigFile(const std::string& fileName, const std::string& rootNode);
 
ONIXS_ICEBOE_EXPORTED
void throwCannotApplyConfigurationValue(const std::string& key, const std::string& value);
 
template<typename C> using Setter = std::function<void(C&, const std::string&)>;
template<typename C> using Registry = std::unordered_map<std::string, Setter<C>>;
 
template<typename C, typename Arg>
Setter<C> makeSetter(C& (C::*mf)(Arg))
{
    using Type = typename std::decay<Arg>::type ;
    return [mf](C& obj, const std::string& text)
    {
        (obj.*mf)(Utils::fromString<Type>(text));
    };
}

template<typename C>
void loadFromFile(const std::string& fileName, C& obj, const Registry<C>& reg, const std::string& rootNode, bool ignoreUnknown = true)
{
    const auto map = parseConfigFile(fileName, rootNode);
 
    for (const auto& pair : map)
    {
        const auto& key = pair.first;
        const auto& value = pair.second;
 
        const auto it = reg.find(key);
 
        if(it != reg.end())
        {
            try
            {
                it->second(obj, value);
            }
            catch(...)
            {
                throwCannotApplyConfigurationValue(key, value);
            }
        }
        else if (!ignoreUnknown)
            throw std::invalid_argument("Unknown configuration property '" + key + "'");
    }
}
 
}}
 
ONIXS_ICEBOE_NAMESPACE_END