option.h

Go to the documentation of this file.

#ifndef KOUTIL_ARGS_OPTION_H
#define KOUTIL_ARGS_OPTION_H
 
#include "koutil/args/handle.h"
#include "koutil/args/result.h"
#include <cassert>
#include <functional>
#include <optional>
#include <string_view>
#include <utility>
 
namespace koutil::args {
 
struct option_data_t {
    std::optional<std::string_view> long_name; 
    std::optional<char> short_name; 
    std::string_view description; 
    std::string_view value_name = "value"; 
    bool has_value              = false; 
    bool required               = false; 
};
 
template <extends_result Result = result_base_t> class option_t {
public:
    using result_t = Result;
    using handle_t = std::function<void(std::optional<std::string_view>, result_t&)>;
 
    template <void_handle<std::optional<std::string_view>, result_t&> Handle>
    explicit option_t(const option_data_t& data, Handle&& handle)
        : m_has_value(data.has_value)
        , m_required(data.required)
        , m_long_name(data.long_name)
        , m_short_name(data.short_name)
        , m_description(data.description)
        , m_value_name(data.value_name)
        , m_handle(std::forward<Handle>(handle)) { }
 
    [[nodiscard]] bool required() const { return m_required; }
 
    [[nodiscard]] bool used() const { return m_used; }
 
    [[nodiscard]] auto long_name() const { return m_long_name; }
 
    [[nodiscard]] auto short_name() const { return m_short_name; }
 
    [[nodiscard]] std::string_view description() const { return m_description; }
 
    [[nodiscard]] bool has_value() const { return m_has_value; }
 
    [[nodiscard]] std::string_view value_name() const { return m_value_name; }
 
    void process(std::optional<std::string_view> value, result_t& result);
 
    void clear_used() { m_used = false; }
 
private:
    bool m_has_value;
    bool m_required;
 
    bool m_used = false;
 
    std::optional<std::string_view> m_long_name;
    std::optional<char> m_short_name;
    std::string_view m_description;
    std::string_view m_value_name;
 
    handle_t m_handle;
};
 
template <extends_result Result>
void option_t<Result>::process(std::optional<std::string_view> value, result_t& result) {
    m_used = true;
 
    if (m_handle) {
        m_handle(value, result);
    }
}
 
}
 
#endif