parameters.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 <cstddef>
#include <format>
#include <limits>
#include <optional>
#include <span>
#include <string>
#include <string_view>
#include <utility>
#include <vector>
 
#include <kaycxx/cli/detail/to_string.hpp>
#include <kaycxx/cli/parameter_base.hpp>
#include <kaycxx/cli/parse_error.hpp>
#include <kaycxx/cli/parse_value.hpp>
 
namespace kaycxx::cli {
 
template <parseable_value T>
class parameters : public parameter_base {
public:
    explicit parameters(std::string_view name, std::optional<std::string_view> description = std::nullopt)
        : parameter_base(name, description)
    {}
 
    void min(std::size_t count) noexcept {
        min_count_ = count;
    }
 
    void max(std::size_t count) noexcept {
        max_count_ = count;
    }
 
    void default_values(std::vector<T> values) {
        auto text = std::string{"["};
        for (auto index = std::size_t{0}; index < values.size(); ++index) {
            if (index > 0) {
                text += ", ";
            }
            text += detail::to_string(values[index]);
        }
        text += "]";
        default_value_text(std::move(text));
        default_values_ = std::move(values);
    }
 
    [[nodiscard]] std::string usage() const override {
        return std::format("<{}>...", name());
    }
 
    [[nodiscard]] std::size_t min_count() const noexcept override {
        return default_values_ ? 0 : min_count_;
    }
 
    [[nodiscard]] std::size_t max_count() const noexcept override {
        return max_count_;
    }
 
    [[nodiscard]] std::any parse_values(std::span<std::string_view const> values) const override {
        if (values.empty() && default_values_) {
            validate_count(default_values_->size());
            return *default_values_;
        }
 
        validate_count(values.size());
 
        auto result = std::vector<T>();
        result.reserve(values.size());
 
        for (auto value : values) {
            try {
                result.push_back(detail::parse_value<T>(value));
            } catch (parse_error const& error) {
                throw parse_error(std::format("{} for parameter <{}>", error.what(), name()));
            }
        }
 
        return result;
    }
 
private:
    void validate_count(std::size_t count) const {
        if (count < min_count_) {
            throw parse_error(std::format("Missing parameter <{}>", name()));
        }
        if (count > max_count_) {
            throw parse_error(std::format("Too many values for parameter <{}>", name()));
        }
    }
 
    std::size_t min_count_ = 0;
 
    std::size_t max_count_ = std::numeric_limits<std::size_t>::max();
 
    std::optional<std::vector<T>> default_values_;
};
 
} // namespace kaycxx::cli