predefined_actions.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/exceptions.hpp"
#include "detail/utility.hpp"
 
#include <filesystem>
#include <ostream>
 
namespace ap {
 
class argument_parser;
std::ostream& operator<<(std::ostream& os, const argument_parser&) noexcept;
 
namespace action {
 
inline typename ap::action_type::on_flag::type print_config(
    const argument_parser& parser,
    const std::optional<int> exit_code = std::nullopt,
    std::ostream& os = std::cout
) noexcept {
    return [&parser, &os, exit_code]() {
        os << parser << std::endl;
        if (exit_code)
            std::exit(exit_code.value());
    };
}
 
inline detail::callable_type<ap::action_type::observe, std::string> check_file_exists() noexcept {
    return [](const std::string& file_path) {
        if (not std::filesystem::exists(file_path))
            throw std::filesystem::filesystem_error(
                "File does not exists!",
                file_path,
                std::make_error_code(std::errc::no_such_file_or_directory)
            );
    };
}
 
template <ap::detail::c_arithmetic T>
detail::callable_type<ap::action_type::observe, T> gt(const T lower_bound) noexcept {
    return [lower_bound](const T& value) {
        if (not (value > lower_bound))
            throw std::out_of_range(
                std::format("Value `{}` must be greater than `{}`!", value, lower_bound)
            );
    };
}
 
template <ap::detail::c_arithmetic T>
detail::callable_type<ap::action_type::observe, T> geq(const T lower_bound) noexcept {
    return [lower_bound](const T& value) {
        if (! (value >= lower_bound))
            throw std::out_of_range(
                std::format("Value `{}` must be greater than or equal to `{}`!", value, lower_bound)
            );
    };
}
 
template <ap::detail::c_arithmetic T>
detail::callable_type<ap::action_type::observe, T> lt(const T upper_bound) noexcept {
    return [upper_bound](const T& value) {
        if (! (value < upper_bound))
            throw std::out_of_range(
                std::format("Value `{}` must be less than `{}`!", value, upper_bound)
            );
    };
}
 
template <ap::detail::c_arithmetic T>
detail::callable_type<ap::action_type::observe, T> leq(const T upper_bound) noexcept {
    return [upper_bound](const T& value) {
        if (! (value <= upper_bound))
            throw std::out_of_range(
                std::format("Value `{}` must be less than or equal to `{}`!", value, upper_bound)
            );
    };
}
 
template <ap::detail::c_arithmetic T, bool LeftInclusive = true, bool RightInclusive = true>
detail::callable_type<ap::action_type::observe, T> within(
    const T lower_bound, const T upper_bound
) noexcept {
    return [lower_bound, upper_bound](const T& value) {
        constexpr char left_brace = LeftInclusive ? '[' : '(';
        constexpr char right_brace = RightInclusive ? ']' : ')';
 
        const bool is_valid =
            (LeftInclusive ? value >= lower_bound : value > lower_bound)
            and (RightInclusive ? value <= upper_bound : value < upper_bound);
 
        if (not is_valid)
            throw std::out_of_range(std::format(
                "Value `{}` must be in interval {}{}, {}{}!",
                value,
                left_brace,
                lower_bound,
                upper_bound,
                right_brace
            ));
    };
}
 
} // namespace action
} // namespace ap