ArgsParser.h

Go to the documentation of this file.

#pragma once
 
#include "io/Logger.h"
#include "objects/Exceptions.h"
#include "objects/containers/FlatMap.h"
#include "objects/wrappers/Function.h"
#include "objects/wrappers/SharedPtr.h"
#include "objects/wrappers/Variant.h"
#include "system/Settings.h"
 
NAMESPACE_SPH_BEGIN
 
enum class ArgEnum {
    NONE, 
    BOOL,
    INT,
    FLOAT,
    STRING,
};
 
 
class ArgError : public Exception {
public:
    explicit ArgError(const std::string& message)
        : Exception(message) {}
};
 
class HelpException : public Exception {
public:
    explicit HelpException(const std::string& message)
        : Exception(message) {}
};
 
struct ArgDesc {
    std::string shortName;
 
    std::string longName;
 
    ArgEnum type;
 
    std::string desc;
 
    Function<void()> callback = nullptr;
 
    bool matches(const std::string& name) {
        return (name == "-" + shortName) || (name == "--" + longName);
    }
};
 
class ArgParser {
private:
    using ArgValue = Variant<int, Float, bool, std::string>;
 
    Array<ArgDesc> descs;
 
    FlatMap<std::string, ArgValue> params;
 
public:
    explicit ArgParser(ArrayView<const ArgDesc> args);
 
    void parse(const int argc, char** argv);
 
    void printHelp(ILogger& logger);
 
    template <typename TValue>
    TValue getArg(const std::string& name) const {
        throwIfUnknownArg(name);
        Optional<const ArgValue&> value = params.tryGet(name);
        if (value && value->has<TValue>()) {
            return value->get<TValue>();
        } else {
            const std::string message = value ? "Invalid type of argument -" : "Missing argument -" + name;
            throw ArgError(message);
        }
    }
 
    template <typename TValue>
    Optional<TValue> tryGetArg(const std::string& name) const {
        throwIfUnknownArg(name);
        Optional<const ArgValue&> value = params.tryGet(name);
        if (value) {
            if (!value->has<TValue>()) {
                throw ArgError("Invalid type");
            }
            return value->get<TValue>();
        } else {
            return NOTHING;
        }
    }
 
    template <typename TEnum, typename TConvertor>
    bool tryStore(Settings<TEnum>& settings, const std::string& name, const TEnum idx, TConvertor&& conv) {
        throwIfUnknownArg(name);
        auto value = params.tryGet(name);
        if (value) {
            // special handling of floats - convert units
            if (value->has<Float>()) {
                settings.set(idx, conv(value->get<Float>()));
            } else {
                forValue(value.value(), [&settings, idx](auto& value) { settings.set(idx, value); });
            }
            return true;
        }
        return false;
    }
 
    template <typename TEnum>
    bool tryStore(Settings<TEnum>& settings, const std::string& name, const TEnum idx) {
        return tryStore(settings, name, idx, [](Float value) { return value; });
    }
 
    template <typename TFunctor>
    void forEach(const TFunctor& functor) {
        for (auto& e : params) {
            forValue(e.value, [&e, &functor](auto& value) { functor(e.key, value); });
        }
    }
 
    Size size() const {
        return params.size();
    }
 
    bool empty() const {
        return params.empty();
    }
 
private:
    void parseValuelessArg(const ArgDesc& desc);
 
    void parseValueArg(const ArgDesc& desc, const std::string& value);
 
    template <typename TValue>
    void insertArg(const std::string& name, const std::string& textValue);
 
    void throwIfUnknownArg(const std::string& name) const;
};
 
 
NAMESPACE_SPH_END