VirtualSettings.h

Go to the documentation of this file.

#pragma once
 
 
#include "io/Path.h"
#include "objects/containers/CallbackSet.h"
#include "objects/containers/UnorderedMap.h"
#include "system/Settings.h"
 
NAMESPACE_SPH_BEGIN
 
class IExtraEntry : public Polymorphic {
public:
    virtual std::string toString() const = 0;
 
    virtual void fromString(const std::string& s) = 0;
 
    virtual AutoPtr<IExtraEntry> clone() const = 0;
};
 
class ExtraEntry {
public:
    AutoPtr<IExtraEntry> entry;
 
public:
    explicit ExtraEntry(AutoPtr<IExtraEntry>&& entry)
        : entry(std::move(entry)) {}
 
    ExtraEntry(const ExtraEntry& other)
        : entry(other.entry->clone()) {}
 
    ExtraEntry& operator=(const ExtraEntry& other) {
        entry = other.entry->clone();
        return *this;
    }
 
    std::string toString() const {
        return entry->toString();
    }
 
    void fromString(const std::string& s) const {
        entry->fromString(s);
    }
 
    RawPtr<IExtraEntry> getEntry() const {
        return entry.get();
    }
};
 
class IVirtualEntry : public Polymorphic {
public:
    enum class Type { BOOL, INT, FLOAT, VECTOR, INTERVAL, STRING, PATH, ENUM, EXTRA, FLAGS };
 
    using Value = Variant<bool, int, Float, Vector, Interval, std::string, Path, EnumWrapper, ExtraEntry>;
 
    virtual bool enabled() const = 0;
 
    virtual bool set(const Value& value) = 0;
 
    virtual Value get() const = 0;
 
    virtual bool isValid(const Value& value) const = 0;
 
    virtual Type getType() const = 0;
 
    virtual std::string getName() const = 0;
 
    virtual std::string getTooltip() const {
        return "";
    }
 
    virtual bool hasSideEffect() const {
        return false;
    }
 
    enum class PathType {
        DIRECTORY,
        INPUT_FILE,
        OUTPUT_FILE,
    };
 
    virtual Optional<PathType> getPathType() const {
        return NOTHING;
    }
 
    struct FileFormat {
        std::string description;
        std::string extension;
    };
 
    virtual Array<FileFormat> getFileFormats() const {
        return {};
    }
};
 
class EntryControl : public IVirtualEntry {
public:
    using Enabler = Function<bool()>;
    using Accessor = Function<void(const Value& newValue)>;
    using Validator = Function<bool(const Value& newValue)>;
 
protected:
    std::string tooltip;
    Float mult = 1._f;
    Optional<PathType> pathType = NOTHING;
    Array<FileFormat> fileFormats;
    Enabler enabler = nullptr;
    CallbackSet<Accessor> accessors;
    Validator validator = nullptr;
    bool sideEffect = false;
 
public:
    EntryControl& setTooltip(const std::string& newTooltip);
 
    EntryControl& setUnits(const Float newMult);
 
    EntryControl& setEnabler(const Enabler& newEnabler);
 
    EntryControl& addAccessor(const SharedToken& owner, const Accessor& accessor);
 
    EntryControl& setValidator(const Validator& newValidator);
 
    EntryControl& setSideEffect();
 
    EntryControl& setPathType(const PathType& newType);
 
    EntryControl& setFileFormats(Array<FileFormat>&& formats);
 
protected:
    virtual bool enabled() const override final;
 
    virtual std::string getTooltip() const override final;
 
    virtual bool hasSideEffect() const override final;
 
    virtual Optional<PathType> getPathType() const override final;
 
    virtual Array<FileFormat> getFileFormats() const override final;
 
    virtual bool isValid(const Value& value) const override final;
 
    virtual void setImpl(const Value& value) = 0;
 
private:
    virtual bool set(const Value& value) override final;
};
 
class VirtualSettings {
public:
    class Category {
        friend class VirtualSettings;
 
    private:
        UnorderedMap<std::string, AutoPtr<IVirtualEntry>> entries;
 
    public:
        void addEntry(const std::string& key, AutoPtr<IVirtualEntry>&& entry);
 
        template <typename TValue>
        EntryControl& connect(const std::string& name, const std::string& key, TValue& value);
 
        template <typename TValue, typename TEnum>
        EntryControl& connect(const std::string& name, Settings<TEnum>& settings, const TEnum id);
    };
 
 
private:
    UnorderedMap<std::string, Category> categories;
 
public:
    void set(const std::string& key, const IVirtualEntry::Value& value);
 
    template <typename TEnum, typename = std::enable_if_t<std::is_enum<TEnum>::value>>
    void set(const TEnum id, const IVirtualEntry::Value& value);
 
    IVirtualEntry::Value get(const std::string& key) const;
 
    Category& addCategory(const std::string& name);
 
    class IEntryProc : public Polymorphic {
    public:
        virtual void onCategory(const std::string& name) const = 0;
 
        virtual void onEntry(const std::string& key, IVirtualEntry& entry) const = 0;
    };
 
    void enumerate(const IEntryProc& proc);
};
 
Array<IVirtualEntry::FileFormat> getInputFormats();
 
Array<IVirtualEntry::FileFormat> getOutputFormats();
 
NAMESPACE_SPH_END
 
#include "run/VirtualSettings.inl.h"