option.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 Klaus Reimer <k@ailis.de>
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include <any>
#include <format>
#include <optional>
#include <stdexcept>
#include <string>
#include <string_view>
#include <utility>
#include <vector>
 
#include <kaycxx/cli/detail/to_string.hpp>
#include <kaycxx/cli/parse_value.hpp>
#include <kaycxx/cli/switch_base.hpp>
 
namespace kaycxx::cli {
 
template <parseable_value T>
class option_handle;
 
template <parseable_value T>
class repeatable_option_handle;
 
class option_base : public switch_base {
public:
    using switch_base::switch_base;
 
    [[nodiscard]] virtual std::string const& value_name() const noexcept = 0;
 
    [[nodiscard]] virtual std::optional<std::any> default_value() const = 0;
 
    [[nodiscard]] std::optional<std::string> const& default_value_text() const noexcept {
        return default_value_text_;
    }
 
    [[nodiscard]] bool is_required() const noexcept {
        return required_;
    }
 
    [[nodiscard]] bool is_repeatable() const noexcept {
        return repeatable_;
    }
 
protected:
    void mark_as_defaulted(std::string text) {
        if (required_) {
            throw std::invalid_argument{std::format("Option --{} cannot be both required and defaulted", name())};
        }
        default_value_text_ = std::move(text);
    }
 
private:
    friend class command;
 
    template <parseable_value T>
    friend class option_handle;
 
    template <parseable_value T>
    friend class repeatable_option_handle;
 
    void mark_as_required() {
        if (default_value_text_) {
            throw std::invalid_argument{std::format("Option --{} cannot be both required and defaulted", name())};
        }
        required_ = true;
    }
 
    void mark_as_repeatable() noexcept {
        repeatable_ = true;
    }
 
    [[nodiscard]] virtual std::any parse_value(std::string_view text) const = 0;
 
    virtual void append_value(std::any& storage, std::string_view text) const = 0;
 
    bool repeatable_ = false;
 
    bool required_ = false;
 
    std::optional<std::string> default_value_text_;
};
 
template <parseable_value T>
class option : public option_base {
public:
    explicit option(std::string_view name, std::string_view value_name, std::optional<std::string_view> description = std::nullopt)
        : option_base(name, description),
          value_name_(value_name) {}
 
    explicit option(std::string_view name, char alias, std::string_view value_name, std::optional<std::string_view> description = std::nullopt)
        : option_base(name, alias, description),
          value_name_(value_name) {}
 
    [[nodiscard]] std::string const& value_name() const noexcept override {
        return value_name_;
    }
 
    void default_value(T value) {
        mark_as_defaulted(detail::to_string(value));
        default_value_ = std::move(value);
    }
 
    [[nodiscard]] std::string usage() const override {
        if (auto alias = this->alias()) {
            return std::format("-{}, --{} <{}>", *alias, name(), value_name_);
        }
 
        return std::format("    --{} <{}>", name(), value_name_);
    }
 
    [[nodiscard]] bool expects_value() const noexcept override {
        return true;
    }
 
    [[nodiscard]] std::optional<std::any> default_value() const override {
        if (default_value_) {
            if (is_repeatable()) {
                auto values = std::vector<T>();
                values.push_back(*default_value_);
                return std::any(std::move(values));
            }
            return std::any(*default_value_);
        }
 
        return std::nullopt;
    }
 
private:
    [[nodiscard]] std::any parse_value(std::string_view text) const override {
        return detail::parse_value<T>(text);
    }
 
    void append_value(std::any& storage, std::string_view text) const override {
        auto value = detail::parse_value<T>(text);
        if (!storage.has_value()) {
            storage = std::vector<T>();
        }
        std::any_cast<std::vector<T>&>(storage).push_back(std::move(value));
    }
 
    std::string value_name_;
 
    std::optional<T> default_value_;
};
 
} // namespace kaycxx::cli