optional.hpp

Go to the documentation of this file.

// Copyright (c) 2023-2025 Jakub Musiał
// This file is part of the CPP-AP project (https://github.com/SpectraL519/cpp-ap).
// Licensed under the MIT License. See the LICENSE file in the project root for full license information.
 
 
#pragma once
 
#include "ap/action/detail/utility.hpp"
#include "ap/action/predefined_actions.hpp"
#include "ap/detail/argument_base.hpp"
#include "ap/detail/argument_descriptor.hpp"
#include "ap/detail/concepts.hpp"
#include "ap/nargs/range.hpp"
 
#ifdef AP_TESTING
 
namespace ap_testing {
struct optional_argument_test_fixture;
} // namespace ap_testing
 
#endif
 
namespace ap::argument {
 
template <detail::c_argument_value_type T = std::string>
class optional : public detail::argument_base {
public:
    using value_type = T; 
    using count_type = nargs::range::count_type; 
 
    optional() = delete;
 
    optional(const detail::argument_name& name) : argument_base(name) {}
 
    ~optional() = default;
 
    bool operator==(const optional& other) const noexcept {
        return this->_name == other._name;
    }
 
    optional& help(std::string_view help_msg) noexcept {
        this->_help_msg = help_msg;
        return *this;
    }
 
    optional& hidden(const bool h = true) noexcept {
        this->_hidden = h;
        return *this;
    }
 
    optional& required(const bool r = true) noexcept {
        this->_required = r;
        if (this->_required)
            this->_bypass_required = false;
        return *this;
    }
 
    optional& bypass_required(const bool br = true) noexcept {
        this->_bypass_required = br;
        if (this->_bypass_required)
            this->_required = false;
        return *this;
    }
 
    optional& nargs(const nargs::range& range) noexcept {
        this->_nargs_range = range;
        return *this;
    }
 
    optional& nargs(const count_type n) noexcept {
        this->_nargs_range = nargs::range(n);
        return *this;
    }
 
    optional& nargs(const count_type lower_bound, const count_type upper_bound) noexcept {
        this->_nargs_range = nargs::range(lower_bound, upper_bound);
        return *this;
    }
 
    template <action::detail::c_action_specifier AS, typename F>
    optional& action(F&& action) noexcept {
        if constexpr (action::detail::c_value_action_specifier<AS>) {
            using callable_type = action::detail::callable_type<AS, value_type>;
            this->_value_actions.emplace_back(std::forward<callable_type>(action));
        }
        else {
            this->_flag_actions.emplace_back(std::forward<flag_action_type>(action));
        }
 
        return *this;
    }
 
    template <detail::c_range_of<value_type, detail::type_validator::convertible> CR>
    optional& choices(const CR& choices) noexcept
    requires(std::equality_comparable<value_type>)
    {
        for (const auto& choice : choices)
            this->_choices.emplace_back(choice);
        return *this;
    }
 
    optional& choices(std::initializer_list<value_type> choices) noexcept
    requires(std::equality_comparable<value_type>)
    {
        return this->choices<>(choices);
    }
 
    optional& default_value(const std::convertible_to<value_type> auto& default_value) noexcept {
        this->_default_value = std::make_any<value_type>(default_value);
        this->_required = false;
        return *this;
    }
 
    optional& implicit_value(const std::convertible_to<value_type> auto& implicit_value) noexcept {
        this->_implicit_value = std::make_any<value_type>(implicit_value);
        return *this;
    }
 
    friend class ::ap::argument_parser;
 
#ifdef AP_TESTING
    friend struct ::ap_testing::optional_argument_test_fixture;
#endif
 
private:
    using value_action_type =
        action::detail::value_action_variant_type<T>; 
    using flag_action_type = typename action_type::on_flag::type;
 
    [[nodiscard]] detail::argument_descriptor desc(const bool verbose) const noexcept override {
        detail::argument_descriptor desc(this->_name.str(), this->_help_msg);
 
        if (not verbose)
            return desc;
 
        desc.params.reserve(6);
        if (this->_required)
            desc.add_param("required", "true");
        if (this->bypass_required_enabled())
            desc.add_param("bypass required", "true");
        if (this->_nargs_range.is_bound())
            desc.add_param("nargs", this->_nargs_range);
        if constexpr (detail::c_writable<value_type>) {
            if (not this->_choices.empty())
                desc.add_range_param("choices", this->_choices);
            if (this->_default_value.has_value())
                desc.add_param("default value", std::any_cast<value_type>(this->_default_value));
            if (this->_implicit_value.has_value())
                desc.add_param("implicit value", std::any_cast<value_type>(this->_implicit_value));
        }
 
        return desc;
    }
 
    bool mark_used() override {
        ++this->_count;
        for (const auto& action : this->_flag_actions)
            action();
        return this->_accepts_further_values();
    }
 
    [[nodiscard]] bool is_used() const noexcept override {
        return this->_count > 0;
    }
 
    [[nodiscard]] std::size_t count() const noexcept override {
        return this->_count;
    }
 
    bool set_value(const std::string& str_value) override {
        if (not this->_accepts_further_values())
            throw parsing_failure::invalid_nvalues(this->_name, std::weak_ordering::greater);
 
        value_type value;
        if constexpr (detail::c_trivially_readable<value_type>) {
            value = value_type(str_value);
        }
        else {
            if (not (std::istringstream(str_value) >> value))
                throw parsing_failure::invalid_value(this->_name, str_value);
        }
 
        if (not detail::is_valid_choice(value, this->_choices))
            throw parsing_failure::invalid_choice(this->_name, str_value);
 
        const auto apply_visitor = action::detail::apply_visitor<value_type>{value};
        for (const auto& action : this->_value_actions)
            std::visit(apply_visitor, action);
 
        this->_values.emplace_back(std::move(value));
        return this->_accepts_further_values();
    }
 
    [[nodiscard]] bool has_value() const noexcept override {
        return this->has_parsed_values() or this->_has_predefined_value();
    }
 
    [[nodiscard]] bool has_parsed_values() const noexcept override {
        return not this->_values.empty();
    }
 
    [[nodiscard]] std::weak_ordering nvalues_ordering() const noexcept override {
        if (this->_values.empty() and this->_has_predefined_value())
            return std::weak_ordering::equivalent;
 
        return this->_nargs_range.ordering(this->_values.size());
    }
 
    [[nodiscard]] const std::any& value() const override {
        return this->_values.empty() ? this->_predefined_value() : this->_values.front();
    }
 
    [[nodiscard]] const std::vector<std::any>& values() const override {
        return this->_values;
    }
 
    [[nodiscard]] bool _has_predefined_value() const noexcept {
        return this->_default_value.has_value()
            or (this->is_used() and this->_implicit_value.has_value());
    }
 
    [[nodiscard]] const std::any& _predefined_value() const {
        if (this->is_used()) {
            if (not this->_implicit_value.has_value())
                throw(std::logic_error(
                    std::format("No implicit value specified for argument `{}`.", this->_name.str())
                ));
 
            return this->_implicit_value;
        }
 
        if (not this->_default_value.has_value())
            throw(std::logic_error(
                std::format("No default value specified for argument `{}`.", this->_name.str())
            ));
 
        return this->_default_value;
    }
 
    [[nodiscard]] bool _accepts_further_values() const noexcept {
        return not std::is_gt(this->_nargs_range.ordering(this->_values.size() + 1ull));
    }
 
    nargs::range _nargs_range = nargs::any();
    std::any _default_value;
    std::any _implicit_value;
    std::vector<value_type> _choices;
    std::vector<flag_action_type> _flag_actions;
    std::vector<value_action_type> _value_actions;
 
    std::size_t _count = 0ull;
    std::vector<std::any> _values;
};
 
} // namespace ap::argument