args.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 <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
#include <kaycxx/cli/flag_handle.hpp>
#include <kaycxx/cli/option_handle.hpp>
#include <kaycxx/cli/parameter_base.hpp>
#include <kaycxx/cli/parameter_handle.hpp>
#include <kaycxx/cli/parameters_handle.hpp>
#include <kaycxx/cli/repeatable_option_handle.hpp>
#include <kaycxx/cli/switch_base.hpp>
 
namespace kaycxx::cli {
 
class command;
class command_handle;
 
class args {
public:
    args() = default;
 
    args(args const&) = delete;
 
    args& operator=(args const&) = delete;
 
    args(args&& other) noexcept = default;
 
    args& operator=(args&& other) noexcept = default;
 
    void validate() const;
 
    [[nodiscard]] command const& selected_command() const;
 
    [[nodiscard]] bool is_selected(command const& command) const noexcept;
 
    [[nodiscard]] bool is_selected(command_handle const& command) const noexcept;
 
    [[nodiscard]] bool get(flag_handle const& flag) const;
 
    template <parseable_value T>
    [[nodiscard]] T const& get(option_handle<T> const& option) const {
        return std::any_cast<T const&>(values_.at(&option.definition()));
    }
 
    template <parseable_value T>
    [[nodiscard]] bool has(option_handle<T> const& option) const {
        return values_.contains(&option.definition());
    }
 
    template <parseable_value T>
    [[nodiscard]] std::vector<T> const& get(repeatable_option_handle<T> const& option) const {
        return std::any_cast<std::vector<T> const&>(values_.at(&option.definition()));
    }
 
    template <parseable_value T>
    [[nodiscard]] bool has(repeatable_option_handle<T> const& option) const {
        return values_.contains(&option.definition());
    }
 
    template <parseable_value T>
    [[nodiscard]] T const& get(parameter_handle<T> const& parameter) const {
        validate();
        return std::any_cast<T const&>(parameters_.at(&parameter.definition()));
    }
 
    template <parseable_value T>
    [[nodiscard]] bool has(parameter_handle<T> const& parameter) const {
        validate();
        return parameters_.contains(&parameter.definition());
    }
 
    template <parseable_value T>
    [[nodiscard]] std::vector<T> const& get(parameters_handle<T> const& parameters) const {
        validate();
        return std::any_cast<std::vector<T> const&>(parameters_.at(&parameters.definition()));
    }
 
    template <parseable_value T>
    [[nodiscard]] bool has(parameters_handle<T> const& parameters) const {
        validate();
        return parameters_.contains(&parameters.definition());
    }
 
private:
    friend class command;
 
    command const* selected_command_ = nullptr;
 
    bool missing_subcommand_ = false;
 
    std::unordered_set<switch_base const*> flags_;
 
    std::unordered_map<switch_base const*, std::any> values_;
 
    std::vector<option_base const*> required_option_definitions_;
 
    std::vector<parameter_base const*> parameter_definitions_;
 
    std::vector<std::string> positional_values_;
 
    mutable std::unordered_map<parameter_base const*, std::any> parameters_;
 
    mutable bool validated_ = false;
};
 
} // namespace kaycxx::cli