Config.h

Go to the documentation of this file.

#pragma once
 
 
#include "io/Path.h"
#include "objects/Exceptions.h"
#include "objects/containers/UnorderedMap.h"
#include "objects/geometry/Vector.h"
#include "objects/utility/StringUtils.h"
#include "objects/wrappers/Function.h"
 
NAMESPACE_SPH_BEGIN
 
using ConfigException = Exception;
 
class IConfigValue : public Polymorphic {
public:
    virtual std::string write() const = 0;
 
    virtual void read(const std::string& source) = 0;
};
 
std::string quoted(const std::string& value);
 
std::string unquoted(const std::string& value);
 
template <typename Type>
class ConfigValue : public IConfigValue {
private:
    Type value;
 
public:
    ConfigValue() = default;
 
    ConfigValue(const Type& value)
        : value(value) {}
 
    virtual std::string write() const override {
        std::stringstream ss;
        ss << value;
        return ss.str();
    }
 
    virtual void read(const std::string& source) override {
        std::stringstream ss(trim(source));
        ss >> value;
 
        if (!ss || !ss.eof()) {
            throw ConfigException("Invalid type");
        }
    }
 
    Type get() const {
        return value;
    }
};
 
template <>
class ConfigValue<Vector> : public IConfigValue {
private:
    Vector value;
 
public:
    ConfigValue() = default;
 
    ConfigValue(const Vector& value)
        : value(value) {}
 
    virtual std::string write() const override {
        std::stringstream ss;
        ss << value;
        return ss.str();
    }
 
    virtual void read(const std::string& source) override {
        std::stringstream ss(source);
        ss >> value[X] >> value[Y] >> value[Z];
    }
 
    Vector get() const {
        return value;
    }
};
 
template <>
class ConfigValue<Interval> : public IConfigValue {
private:
    Interval value;
 
public:
    ConfigValue() = default;
 
    ConfigValue(const Interval& value)
        : value(value) {}
 
    virtual std::string write() const override {
        std::stringstream ss;
        ss << value;
        return ss.str();
    }
 
    virtual void read(const std::string& source) override {
        std::stringstream ss(source);
        Float lower, upper;
        ss >> lower >> upper;
        value = Interval(lower, upper);
    }
 
    Interval get() const {
        return value;
    }
};
 
template <>
class ConfigValue<std::string> : public IConfigValue {
private:
    std::string value;
 
public:
    ConfigValue() = default;
 
    ConfigValue(const std::string& value)
        : value(value) {}
 
    virtual std::string write() const override {
        return quoted(value);
    }
 
    virtual void read(const std::string& source) override {
        value = unquoted(source);
    }
 
    const std::string& get() const {
        return value;
    }
};
 
template <>
class ConfigValue<Path> : public IConfigValue {
private:
    Path value;
 
public:
    ConfigValue() = default;
 
    ConfigValue(const Path& value)
        : value(value) {}
 
    virtual std::string write() const override {
        return quoted(value.native());
    }
 
    virtual void read(const std::string& source) override {
        value = Path(unquoted(source));
    }
 
    Path get() const {
        return value;
    }
};
 
class ConfigNode {
    friend class Config;
 
private:
    UnorderedMap<std::string, SharedPtr<ConfigNode>> children;
 
    UnorderedMap<std::string, std::string> entries;
 
public:
    template <typename Type>
    void set(const std::string& name, const Type& value) {
        ConfigValue<Type> writer(value);
        entries.insert(name, writer.write());
    }
 
    template <typename Type>
    Type get(const std::string& name) {
        Optional<Type> opt = this->tryGet<Type>(name);
        if (!opt) {
            throw ConfigException("Entry '" + name + "' not in config");
        }
        return opt.value();
    }
 
    template <typename Type>
    Optional<Type> tryGet(const std::string& name) {
        auto value = entries.tryGet(name);
        if (!value) {
            return NOTHING;
        }
        ConfigValue<Type> reader;
        reader.read(value.value());
        return reader.get();
    }
 
    bool contains(const std::string& name) {
        return entries.contains(name);
    }
 
    Size size() const;
 
    SharedPtr<ConfigNode> addChild(const std::string& name);
 
    SharedPtr<ConfigNode> getChild(const std::string& name);
 
    void enumerateChildren(Function<void(std::string name, ConfigNode& node)> func);
 
private:
    void write(const std::string& padding, std::stringstream& source);
 
    void read(std::stringstream& source);
};
 
class Config {
private:
    UnorderedMap<std::string, SharedPtr<ConfigNode>> nodes;
 
public:
    SharedPtr<ConfigNode> addNode(const std::string& name);
 
    SharedPtr<ConfigNode> getNode(const std::string& name);
 
    SharedPtr<ConfigNode> tryGetNode(const std::string& name);
 
    void read(std::stringstream& source);
 
    std::string write();
 
    void load(const Path& path);
 
    void save(const Path& path);
 
    void enumerate(Function<void(std::string, ConfigNode&)> func);
};
 
 
NAMESPACE_SPH_END