if constexpr (std::is_same_v<T, bool>) {

return val ? "true" : "false";

} else if constexpr (std::is_convertible_v<T, std::string_view>) {

return '"' + std::string{std::string_view{val}} + '"';

} else if constexpr (IsContainer<T>) {

std::stringstream out;

out << "{";

const auto size = val.size();

if (size > 1) {

out << repr(*val.begin());

std::for_each(

std::next(val.begin()),

std::next(

val.begin(),

static_cast<typename T::iterator::difference_type>(

std::min<std::size_t>(size, repr_max_container_size) - 1)),

[&out](const auto &v) { out << " " << repr(v); });

if (size <= repr_max_container_size) {

out << " ";

} else {

out << "...";

}

}

if (size > 0) {

out << repr(*std::prev(val.end()));

}

out << "}";

return out.str();

} else if constexpr (IsStreamable<T>) {

std::stringstream out;

out << val;

return out.str();

} else {

return "<not representable>";

}

std::index_sequence<I...> /*unused*/) {

return std::invoke(std::forward<F>(f), std::get<I>(std::forward<Tuple>(t))...,

std::forward<Extra>(x));

return details::apply_plus_one_impl(

std::forward<F>(f), std::forward<Tuple>(t), std::forward<Extra>(x),

std::make_index_sequence<

std::tuple_size_v<std::remove_reference_t<Tuple>>>{});

scientific = 0xf1,

fixed = 0xf2,

hex = 0xf4,

binary = 0xf8,

general = fixed | scientific

-> ConsumeBinaryPrefixResult {

if (starts_with(std::string_view{"0b"}, s) ||

starts_with(std::string_view{"0B"}, s)) {

s.remove_prefix(2);

return {true, s};

}

return {false, s};

-> ConsumeHexPrefixResult {

if (starts_with("0x"sv, s) || starts_with("0X"sv, s)) {

s.remove_prefix(2);

return {true, s};

}

return {false, s};

T x;

auto [first, last] = pointer_range(s);

auto [ptr, ec] = std::from_chars(first, last, x, Param);

if (ec == std::errc()) {

if (ptr == last) {

return x;

}

throw std::invalid_argument{"pattern '" + std::string(s) +

"' does not match to the end"};

}

if (ec == std::errc::invalid_argument) {

throw std::invalid_argument{"pattern '" + std::string(s) + "' not found"};

}

if (ec == std::errc::result_out_of_range) {

throw std::range_error{"'" + std::string(s) + "' not representable"};

}

return x; // unreachable

auto operator()(std::string_view s) -> T {

return do_from_chars<T, Param>(s);

}

if (isspace(static_cast<unsigned char>(s[0])) || s[0] == '+') {

throw std::invalid_argument{"pattern '" + s + "' not found"};

}

auto [first, last] = pointer_range(s);

char *ptr;

errno = 0;

auto x = generic_strtod<T>(first, &ptr);

if (errno == 0) {

if (ptr == last) {

return x;

}

throw std::invalid_argument{"pattern '" + s +

"' does not match to the end"};

}

if (errno == ERANGE) {

throw std::range_error{"'" + s + "' not representable"};

}

return x; // unreachable

if (first == last) {

return "";

}

std::stringstream value;

value << *first;

++first;

while (first != last) {

value << separator << *first;

++first;

}

return value.str();

template <typename U>

static auto test(int)

-> decltype(std::to_string(std::declval<U>()), std::true_type{});

template <typename U> static auto test(...) -> std::false_type;

static constexpr bool value = decltype(test<T>(0))::value;

using CleanType = typename std::decay<T>::type;

static const bool value = std::is_integral<CleanType>::value ||

std::is_same<CleanType, std::string>::value ||

std::is_same<CleanType, std::string_view>::value ||

std::is_same<CleanType, const char *>::value;

const StringType &s2) {

std::vector<std::vector<std::size_t>> dp(

s1.size() + 1, std::vector<std::size_t>(s2.size() + 1, 0));

for (std::size_t i = 0; i <= s1.size(); ++i) {

for (std::size_t j = 0; j <= s2.size(); ++j) {

if (i == 0) {

dp[i][j] = j;

} else if (j == 0) {

dp[i][j] = i;

} else if (s1[i - 1] == s2[j - 1]) {

dp[i][j] = dp[i - 1][j - 1];

} else {

dp[i][j] = 1 + std::min({dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]});

}

}

}

return dp[s1.size()][s2.size()];

const std::string_view input) {

std::string_view most_similar{};

std::size_t min_distance = std::numeric_limits<std::size_t>::max();

for (const auto &entry : map) {

std::size_t distance = get_levenshtein_distance(entry.first, input);

if (distance < min_distance) {

min_distance = distance;

most_similar = entry.first;

}

}

return most_similar;

none = 0,

help = 1,

version = 2,

all = help | version,

friend class ArgumentParser;

friend auto operator<<(std::ostream &stream, const ArgumentParser &parser)

-> std::ostream &;

template <std::size_t N, std::size_t... I>

explicit Argument(std::string_view prefix_chars,

std::array<std::string_view, N> &&a,

std::index_sequence<I...> /*unused*/)

: m_accepts_optional_like_value(false),

m_is_optional((is_optional(a[I], prefix_chars) || ...)),

m_is_required(false), m_is_repeatable(false), m_is_used(false),

m_prefix_chars(prefix_chars) {

((void)m_names.emplace_back(a[I]), ...);

std::sort(

m_names.begin(), m_names.end(), [](const auto &lhs, const auto &rhs) {

return lhs.size() == rhs.size() ? lhs < rhs : lhs.size() < rhs.size();

});

}

template <std::size_t N>

explicit Argument(std::string_view prefix_chars,

std::array<std::string_view, N> &&a)

: Argument(prefix_chars, std::move(a), std::make_index_sequence<N>{}) {}

Argument &help(std::string help_text) {

m_help = std::move(help_text);

return *this;

}

Argument &metavar(std::string metavar) {

m_metavar = std::move(metavar);

return *this;

}

template <typename T> Argument &default_value(T &&value) {

m_num_args_range = NArgsRange{0, m_num_args_range.get_max()};

m_default_value_repr = details::repr(value);

if constexpr (std::is_convertible_v<T, std::string_view>) {

m_default_value_str = std::string{std::string_view{value}};

} else if constexpr (details::can_invoke_to_string<T>::value) {

m_default_value_str = std::to_string(value);

}

m_default_value = std::forward<T>(value);

return *this;

}

Argument &default_value(const char *value) {

return default_value(std::string(value));

}

Argument &required() {

m_is_required = true;

return *this;

}

Argument &implicit_value(std::any value) {

m_implicit_value = std::move(value);

m_num_args_range = NArgsRange{0, 0};

return *this;

}

// This is shorthand for:

// program.add_argument("foo")

// .default_value(false)

// .implicit_value(true)

Argument &flag() {

default_value(false);

implicit_value(true);

return *this;

}

template <class F, class... Args>

auto action(F &&callable, Args &&...bound_args)

-> std::enable_if_t<std::is_invocable_v<F, Args..., std::string const>,

Argument &> {

using action_type = std::conditional_t<

std::is_void_v<std::invoke_result_t<F, Args..., std::string const>>,

void_action, valued_action>;

if constexpr (sizeof...(Args) == 0) {

m_action.emplace<action_type>(std::forward<F>(callable));

} else {

m_action.emplace<action_type>(

[f = std::forward<F>(callable),

tup = std::make_tuple(std::forward<Args>(bound_args)...)](

std::string const &opt) mutable {

return details::apply_plus_one(f, tup, opt);

});

}

return *this;

}

auto &append() {

m_is_repeatable = true;

return *this;

}

template <char Shape, typename T>

auto scan() -> std::enable_if_t<std::is_arithmetic_v<T>, Argument &> {

static_assert(!(std::is_const_v<T> || std::is_volatile_v<T>),

"T should not be cv-qualified");

auto is_one_of = [](char c, auto... x) constexpr {

return ((c == x) || ...);

};

if constexpr (is_one_of(Shape, 'd') && details::standard_integer<T>) {

action(details::parse_number<T, details::radix_10>());

} else if constexpr (is_one_of(Shape, 'i') &&

details::standard_integer<T>) {

action(details::parse_number<T>());

} else if constexpr (is_one_of(Shape, 'u') &&

details::standard_unsigned_integer<T>) {

action(details::parse_number<T, details::radix_10>());

} else if constexpr (is_one_of(Shape, 'b') &&

details::standard_unsigned_integer<T>) {

action(details::parse_number<T, details::radix_2>());

} else if constexpr (is_one_of(Shape, 'o') &&

details::standard_unsigned_integer<T>) {

action(details::parse_number<T, details::radix_8>());

} else if constexpr (is_one_of(Shape, 'x', 'X') &&

details::standard_unsigned_integer<T>) {

action(details::parse_number<T, details::radix_16>());

} else if constexpr (is_one_of(Shape, 'a', 'A') &&

std::is_floating_point_v<T>) {

action(details::parse_number<T, details::chars_format::hex>());

} else if constexpr (is_one_of(Shape, 'e', 'E') &&

std::is_floating_point_v<T>) {

action(details::parse_number<T, details::chars_format::scientific>());

} else if constexpr (is_one_of(Shape, 'f', 'F') &&

std::is_floating_point_v<T>) {

action(details::parse_number<T, details::chars_format::fixed>());

} else if constexpr (is_one_of(Shape, 'g', 'G') &&

std::is_floating_point_v<T>) {

action(details::parse_number<T, details::chars_format::general>());

} else {

static_assert(alignof(T) == 0, "No scan specification for T");

}

return *this;

}

Argument &nargs(std::size_t num_args) {

m_num_args_range = NArgsRange{num_args, num_args};

return *this;

}

Argument &nargs(std::size_t num_args_min, std::size_t num_args_max) {

m_num_args_range = NArgsRange{num_args_min, num_args_max};

return *this;

}

Argument &nargs(nargs_pattern pattern) {

switch (pattern) {

case nargs_pattern::optional:

m_num_args_range = NArgsRange{0, 1};

break;

case nargs_pattern::any:

m_num_args_range =

NArgsRange{0, (std::numeric_limits<std::size_t>::max)()};

break;

case nargs_pattern::at_least_one:

m_num_args_range =

NArgsRange{1, (std::numeric_limits<std::size_t>::max)()};

break;

}

return *this;

}

Argument &remaining() {

m_accepts_optional_like_value = true;

return nargs(nargs_pattern::any);

}

template <typename T> void add_choice(T &&choice) {

static_assert(details::IsChoiceTypeSupported<T>::value,

"Only string or integer type supported for choice");

static_assert(std::is_convertible_v<T, std::string_view> ||

details::can_invoke_to_string<T>::value,

"Choice is not convertible to string_type");

if (!m_choices.has_value()) {

m_choices = std::vector<std::string>{};

}

if constexpr (std::is_convertible_v<T, std::string_view>) {

m_choices.value().push_back(

std::string{std::string_view{std::forward<T>(choice)}});

} else if constexpr (details::can_invoke_to_string<T>::value) {

m_choices.value().push_back(std::to_string(std::forward<T>(choice)));

}

}

Argument &choices() {

if (!m_choices.has_value()) {

throw std::runtime_error("Zero choices provided");

}

return *this;

}

template <typename T, typename... U>

Argument &choices(T &&first, U &&...rest) {

add_choice(std::forward<T>(first));

choices(std::forward<U>(rest)...);

return *this;

}

void find_default_value_in_choices_or_throw() const {

const auto &choices = m_choices.value();

if (m_default_value.has_value()) {

if (std::find(choices.begin(), choices.end(), m_default_value_str) ==

choices.end()) {

// provided arg not in list of allowed choices

// report error

std::string choices_as_csv =

std::accumulate(choices.begin(), choices.end(), std::string(),

[](const std::string &a, const std::string &b) {

return a + (a.empty() ? "" : ", ") + b;

});

throw std::runtime_error(

std::string{"Invalid default value "} + m_default_value_repr +

" - allowed options: {" + choices_as_csv + "}");

}

}

}

template <typename Iterator>

void find_value_in_choices_or_throw(Iterator it) const {

const auto &choices = m_choices.value();

if (std::find(choices.begin(), choices.end(), *it) == choices.end()) {

// provided arg not in list of allowed choices

// report error

std::string choices_as_csv =

std::accumulate(choices.begin(), choices.end(), std::string(),

[](const std::string &a, const std::string &b) {

return a + (a.empty() ? "" : ", ") + b;

});

throw std::runtime_error(std::string{"Invalid argument "} +

details::repr(*it) + " - allowed options: {" +

choices_as_csv + "}");

}

}

template <typename Iterator>

Iterator consume(Iterator start, Iterator end,

std::string_view used_name = {}) {

if (!m_is_repeatable && m_is_used) {

throw std::runtime_error("Duplicate argument");

}

m_is_used = true;

m_used_name = used_name;

if (m_choices.has_value()) {

// Check each value in (start, end) and make sure

// it is in the list of allowed choices/options

for (auto it = start; it != end; ++it) {

find_value_in_choices_or_throw(it);

}

}

const auto num_args_max = m_num_args_range.get_max();

const auto num_args_min = m_num_args_range.get_min();

std::size_t dist = 0;

if (num_args_max == 0) {

m_values.emplace_back(m_implicit_value);

std::visit([](const auto &f) { f({}); }, m_action);

return start;

}

if ((dist = static_cast<std::size_t>(std::distance(start, end))) >=

num_args_min) {

if (num_args_max < dist) {

end = std::next(start, static_cast<typename Iterator::difference_type>(

num_args_max));

}

if (!m_accepts_optional_like_value) {

end = std::find_if(

start, end,

std::bind(is_optional, std::placeholders::_1, m_prefix_chars));

dist = static_cast<std::size_t>(std::distance(start, end));

if (dist < num_args_min) {

throw std::runtime_error("Too few arguments");

}

}

struct ActionApply {

void operator()(valued_action &f) {

std::transform(first, last, std::back_inserter(self.m_values), f);

}

void operator()(void_action &f) {

std::for_each(first, last, f);

if (!self.m_default_value.has_value()) {

if (!self.m_accepts_optional_like_value) {

self.m_values.resize(

static_cast<std::size_t>(std::distance(first, last)));

}

}

}

Iterator first, last;

Argument &self;

};

std::visit(ActionApply{start, end, *this}, m_action);

return end;

}

if (m_default_value.has_value()) {

return start;

}

throw std::runtime_error("Too few arguments for '" +

std::string(m_used_name) + "'.");

}

/*

void validate() const {

if (m_is_optional) {

// TODO: check if an implicit value was programmed for this argument

if (!m_is_used && !m_default_value.has_value() && m_is_required) {

throw_required_arg_not_used_error();

}

if (m_is_used && m_is_required && m_values.empty()) {

throw_required_arg_no_value_provided_error();

}

} else {

if (!m_num_args_range.contains(m_values.size()) &&

!m_default_value.has_value()) {

throw_nargs_range_validation_error();

}

}

if (m_choices.has_value()) {

// Make sure the default value (if provided)

// is in the list of choices

find_default_value_in_choices_or_throw();

}

}

std::string get_names_csv(char separator = ',') const {

return std::accumulate(

m_names.begin(), m_names.end(), std::string{""},

[&](const std::string &result, const std::string &name) {

return result.empty() ? name : result + separator + name;

});

}

std::string get_usage_full() const {

std::stringstream usage;

usage << get_names_csv('/');

const std::string metavar = !m_metavar.empty() ? m_metavar : "VAR";

if (m_num_args_range.get_max() > 0) {

usage << " " << metavar;

if (m_num_args_range.get_max() > 1) {

usage << "...";

}

}

return usage.str();

}

std::string get_inline_usage() const {

std::stringstream usage;

// Find the longest variant to show in the usage string

std::string longest_name = m_names.front();

for (const auto &s : m_names) {

if (s.size() > longest_name.size()) {

longest_name = s;

}

}

if (!m_is_required) {

usage << "[";

}

usage << longest_name;

const std::string metavar = !m_metavar.empty() ? m_metavar : "VAR";

if (m_num_args_range.get_max() > 0) {

usage << " " << metavar;

if (m_num_args_range.get_max() > 1) {

usage << "...";

}

}

if (!m_is_required) {

usage << "]";

}

return usage.str();

}

std::size_t get_arguments_length() const {

std::size_t names_size = std::accumulate(

std::begin(m_names), std::end(m_names), std::size_t(0),

[](const auto &sum, const auto &s) { return sum + s.size(); });

if (is_positional(m_names.front(), m_prefix_chars)) {

// A set metavar means this replaces the names

if (!m_metavar.empty()) {

// Indent and metavar

return 2 + m_metavar.size();

}

// Indent and space-separated

return 2 + names_size + (m_names.size() - 1);

}

// Is an option - include both names _and_ metavar

// size = text + (", " between names)

std::size_t size = names_size + 2 * (m_names.size() - 1);

if (!m_metavar.empty() && m_num_args_range == NArgsRange{1, 1}) {

size += m_metavar.size() + 1;

}