positional.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/concepts.hpp"
 
#ifdef AP_TESTING
 
namespace ap_testing {
struct positional_argument_test_fixture;
} // namespace ap_testing
 
#endif
 
namespace ap::argument {
 
template <detail::c_argument_value_type T = std::string>
class positional : public detail::argument_base {
public:
    using value_type = T; 
 
    positional() = delete;
 
    positional(const detail::argument_name& name) : argument_base(name, true) {}
 
    ~positional() = default;
 
    bool operator==(const positional& other) const noexcept {
        return this->_name == other._name;
    }
 
    positional& help(std::string_view help_msg) noexcept {
        this->_help_msg = help_msg;
        return *this;
    }
 
    positional& hidden(const bool h = true) noexcept {
        this->_hidden = h;
        return *this;
    }
 
    positional& required(const bool r = true) noexcept {
        this->_required = r;
        if (this->_required)
            this->_bypass_required = false;
        return *this;
    }
 
    positional& bypass_required(const bool br = true) noexcept {
        this->_bypass_required = br;
        if (this->_bypass_required)
            this->_required = false;
        return *this;
    }
 
    template <detail::c_range_of<value_type, detail::type_validator::convertible> CR>
    positional& choices(const CR& choices) noexcept
    requires(std::equality_comparable<value_type>)
    {
        for (const auto& choice : choices)
            this->_choices.emplace_back(choice);
        return *this;
    }
 
    positional& choices(std::initializer_list<value_type> choices) noexcept
    requires(std::equality_comparable<value_type>)
    {
        return this->choices<>(choices);
    }
 
    positional& 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;
    }
 
    template <action::detail::c_value_action_specifier AS, std::invocable<value_type&> F>
    positional& action(F&& action) noexcept {
        using callable_type = action::detail::callable_type<AS, value_type>;
        this->_value_actions.emplace_back(std::forward<callable_type>(action));
        return *this;
    }
 
    friend class ::ap::argument_parser;
 
#ifdef AP_TESTING
    friend struct ::ap_testing::positional_argument_test_fixture;
#endif
 
private:
    using value_action_type =
        action::detail::value_action_variant_type<T>; 
 
    [[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;
 
        if (not this->_required)
            desc.add_param("required", "false");
        if (this->bypass_required_enabled())
            desc.add_param("bypass required", "true");
        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));
        }
 
        return desc;
    }
 
    bool mark_used() override {
        return false;
    }
 
    [[nodiscard]] bool is_used() const noexcept override {
        return this->_value.has_value();
    }
 
    [[nodiscard]] std::size_t count() const noexcept override {
        return static_cast<std::size_t>(this->has_parsed_values());
    }
 
    bool set_value(const std::string& str_value) override {
        if (this->_value.has_value())
            throw parsing_failure::value_already_set(this->_name);
 
        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->_value = value;
        return false;
    }
 
    [[nodiscard]] bool has_value() const noexcept override {
        return this->has_parsed_values() or this->_default_value.has_value();
    }
 
    [[nodiscard]] bool has_parsed_values() const noexcept override {
        return this->_value.has_value();
    }
 
    [[nodiscard]] std::weak_ordering nvalues_ordering() const noexcept override {
        if (not this->_required)
            return std::weak_ordering::equivalent;
 
        return this->has_value() ? std::weak_ordering::equivalent : std::weak_ordering::less;
    }
 
    [[nodiscard]] const std::any& value() const override {
        if (this->has_parsed_values())
            return this->_value;
 
        if (this->_default_value.has_value())
            return this->_default_value;
 
        throw std::logic_error(
            std::format("No value parsed for the `{}` positional argument.", this->_name.str())
        );
    }
 
    [[nodiscard]] const std::vector<std::any>& values() const override {
        throw std::logic_error(
            std::format("Positional argument `{}` has only 1 value.", this->_name.str())
        );
    }
 
    std::any _default_value;
    std::vector<value_type> _choices;
    std::vector<value_action_type> _value_actions;
 
    std::any _value; 
};
 
} // namespace ap::argument