337 lines
11 KiB
C++
337 lines
11 KiB
C++
#pragma once
|
|
|
|
#include <chrono>
|
|
#include <concepts>
|
|
#include <coroutine>
|
|
#include <expected>
|
|
#include <ranges>
|
|
|
|
|
|
#include <asio/awaitable.hpp>
|
|
|
|
namespace snplib
|
|
{
|
|
|
|
/* type T is hashable */
|
|
|
|
template <typename T>
|
|
concept hashable_c = requires(T t) {
|
|
{ std::hash<T>{}(t) } -> std::convertible_to<size_t>;
|
|
};
|
|
|
|
/* std::tuple-like types */
|
|
|
|
namespace details
|
|
{
|
|
|
|
template <typename T, size_t... Is>
|
|
concept get_all_indices_c = requires(T t) { (std::get<Is>(t), ...); };
|
|
|
|
template <typename T>
|
|
struct check_indices_t {
|
|
static constexpr bool value = false;
|
|
};
|
|
|
|
// Specialize to extract the index sequence matching the tuple size
|
|
template <typename T>
|
|
requires requires { typename std::tuple_size<T>::type; }
|
|
struct check_indices_t<T> {
|
|
static constexpr bool value = []<std::size_t... Is>(std::index_sequence<Is...>) {
|
|
return get_all_indices_c<T, Is...>;
|
|
}(std::make_index_sequence<std::tuple_size<T>::value>{});
|
|
};
|
|
|
|
template <typename T>
|
|
static constexpr bool check_indices_v = check_indices_t<T>::value;
|
|
|
|
} // namespace details
|
|
|
|
template <typename T>
|
|
concept tuple_like_c = details::check_indices_v<std::remove_cvref_t<T>>;
|
|
|
|
// strictly std::tuple
|
|
template <typename T>
|
|
concept tuple_c = requires {
|
|
[]<typename... Ts>(std::type_identity<std::tuple<Ts...>>) {}(std::type_identity<std::remove_cvref_t<T>>{});
|
|
};
|
|
|
|
|
|
template <typename T, typename ET>
|
|
concept range_of_c = std::ranges::range<T> && std::same_as<std::ranges::range_value_t<T>, ET>;
|
|
|
|
template <typename T, typename ET>
|
|
concept input_range_of_c = std::ranges::input_range<T> && std::same_as<std::ranges::range_value_t<T>, ET>;
|
|
|
|
template <typename T, typename ET>
|
|
concept view_of_c = std::ranges::view<T> && std::same_as<std::ranges::range_value_t<T>, ET>;
|
|
|
|
template <typename T, typename ET>
|
|
concept view_or_output_range_of_c = view_of_c<T, ET> || std::ranges::output_range<T, ET>;
|
|
|
|
template <typename T, typename ET>
|
|
concept range_of_ranges_of_c = std::ranges::range<T> && range_of_c<std::ranges::range_value_t<T>, ET>;
|
|
|
|
|
|
/* some concepts for various types of char sequence */
|
|
|
|
template <typename T, typename CharT = char>
|
|
concept char_range_c = std::ranges::range<T> && std::same_as<std::ranges::range_value_t<T>, CharT>;
|
|
|
|
template <typename T, typename CharT = char>
|
|
concept input_char_range_c = std::ranges::input_range<T> && std::same_as<std::ranges::range_value_t<T>, CharT>;
|
|
|
|
template <typename T, typename CharT = char>
|
|
concept output_char_range_c = std::ranges::output_range<T, CharT>;
|
|
|
|
template <typename T, typename CharT = char>
|
|
concept char_view_c = std::ranges::view<T> && std::same_as<std::ranges::range_value_t<T>, CharT>;
|
|
|
|
template <typename T, typename CharT = char>
|
|
concept view_or_output_char_range_c = char_view_c<T> || output_char_range_c<T, CharT>;
|
|
|
|
template <typename T, typename CharT = char>
|
|
concept range_of_char_views_or_output_ranges_c =
|
|
std::ranges::range<T> && view_or_output_char_range_c<std::ranges::range_value_t<T>, CharT>;
|
|
|
|
|
|
template <typename T, typename CharT = char>
|
|
concept char_range_or_range_of_char_ranges_c =
|
|
char_range_c<T, CharT> || (std::ranges::range<T> && char_range_c<std::ranges::range_value_t<T>, CharT>);
|
|
|
|
template <typename T, typename CharT = char>
|
|
concept char_range_or_tuple_of_char_ranges_c = char_range_c<T, CharT> || requires {
|
|
[]<typename... Rs>(std::type_identity<std::tuple<Rs...>>) {
|
|
static_assert((char_range_c<Rs, CharT> & ...), "Tuple element is not a range of chars!!!");
|
|
}(std::type_identity<std::remove_cvref_t<T>>());
|
|
};
|
|
|
|
|
|
template <typename T, typename CharT = char>
|
|
concept pointer_to_char_c = std::is_pointer_v<T> && std::same_as<CharT, std::remove_const_t<std::remove_pointer_t<T>>>;
|
|
|
|
|
|
|
|
/* std::chrono related concepts */
|
|
|
|
template <typename T>
|
|
concept time_duration_c = requires(T t) {
|
|
[]<typename R, typename P>(std::type_identity<std::chrono::duration<R, P>>) {
|
|
|
|
}(std::type_identity<std::remove_cvref_t<T>>());
|
|
};
|
|
|
|
template <typename T, typename ClockT>
|
|
concept time_point_c = requires(T t) {
|
|
[]<typename DurT>(std::type_identity<std::chrono::time_point<ClockT, DurT>>) {
|
|
|
|
}(std::type_identity<std::remove_cvref_t<T>>());
|
|
};
|
|
|
|
template <typename T>
|
|
concept systime_point_c = time_point_c<T, std::chrono::system_clock>;
|
|
|
|
|
|
template <typename T>
|
|
concept utctime_point_c = time_point_c<T, std::chrono::utc_clock>;
|
|
|
|
template <typename T>
|
|
concept anytime_point_c = systime_point_c<T> || utctime_point_c<T> || time_point_c<T, std::chrono::tai_clock> ||
|
|
time_point_c<T, std::chrono::gps_clock> || time_point_c<T, std::chrono::file_clock> ||
|
|
time_point_c<T, std::chrono::local_t>;
|
|
|
|
|
|
/* callables (NOTE: does not working for templated functions/methods and generic lambdas!) */
|
|
|
|
template <typename T>
|
|
concept callable_c = std::is_function_v<T> || (std::is_object_v<T> && requires(T) { &T::operator(); });
|
|
|
|
|
|
|
|
/* fixed-size and non-resizable ranges */
|
|
|
|
// std::array, std::span(v_t, N), std::tuple
|
|
template <typename T>
|
|
concept fixed_size_range_c = std::ranges::range<T> && requires { std::tuple_size<std::remove_cvref_t<T>>::value; };
|
|
|
|
// non-resizable ranges
|
|
template <typename T>
|
|
concept non_resizable_range_c = std::ranges::range<T> && !requires(T r, std::size_t n) { r.resize(n); };
|
|
|
|
// a range with its own data life-time management
|
|
template <typename T>
|
|
concept owning_range_c = std::ranges::range<T> && !std::is_reference_v<T> &&
|
|
!std::ranges::enable_view<std::decay_t<T>> && std::is_move_constructible_v<T>;
|
|
|
|
/* an concept for error-type */
|
|
|
|
//
|
|
// a default-constructible type wich can be converted to bool-type
|
|
// NOTE: in the SNIPPETS LIBRARY it is assumed that default constructed
|
|
// objects of the 'ret_error_c' types are converted to 'false', i.e.:
|
|
//
|
|
// T v;
|
|
// bool ok = v == false; // 'ok' must be 'true'
|
|
//
|
|
//
|
|
|
|
template <typename T>
|
|
concept ret_error_c = std::constructible_from<T> && requires(T&& t) {
|
|
static_cast<bool>(std::forward<T>(t));
|
|
|
|
// { !std::forward<T>(t) } -> std::convertible_to<bool>;
|
|
};
|
|
|
|
// utility function to deduce error-type
|
|
|
|
template <ret_error_c ErrT, ret_error_c FallbackErrT>
|
|
static auto deduced_ret_error(ErrT const& err, FallbackErrT const& fallback_err)
|
|
{
|
|
if constexpr (std::same_as<ErrT, FallbackErrT>) {
|
|
return err;
|
|
} else if constexpr (std::is_error_code_enum_v<FallbackErrT>) { // special case
|
|
if constexpr (std::same_as<ErrT, std::error_code>) {
|
|
return err;
|
|
} else {
|
|
return fallback_err;
|
|
}
|
|
} else if constexpr (std::is_error_condition_enum_v<FallbackErrT>) { // special case
|
|
if constexpr (std::same_as<ErrT, std::error_condition>) {
|
|
return err;
|
|
} else {
|
|
return fallback_err;
|
|
}
|
|
} else {
|
|
return fallback_err;
|
|
}
|
|
}
|
|
|
|
|
|
template <typename T>
|
|
concept ret_expected_c = requires {
|
|
[]<typename ValT, ret_error_c ErrT>(std::type_identity<std::expected<ValT, ErrT>>) {
|
|
}(std::type_identity<std::remove_cvref_t<T>>{});
|
|
};
|
|
|
|
template <typename T, typename ValT>
|
|
concept ret_expected_type_c = requires {
|
|
[]<ret_error_c ErrT>(std::type_identity<std::expected<ValT, ErrT>>) {
|
|
}(std::type_identity<std::remove_cvref_t<T>>{});
|
|
};
|
|
|
|
template <typename T>
|
|
concept ret_expected_range_c = requires {
|
|
[]<std::ranges::range ValT, ret_error_c ErrT>(std::type_identity<std::expected<ValT, ErrT>>) {
|
|
}(std::type_identity<std::remove_cvref_t<T>>{});
|
|
};
|
|
|
|
|
|
template <typename T>
|
|
concept ret_expected_char_range_c = requires {
|
|
[]<char_range_c ValT, ret_error_c ErrT>(std::type_identity<std::expected<ValT, ErrT>>) {
|
|
}(std::type_identity<std::remove_cvref_t<T>>{});
|
|
};
|
|
|
|
|
|
|
|
// result of asynchronous callable
|
|
|
|
template <typename, typename = std::void_t<>>
|
|
struct has_co_await_operator : std::false_type {
|
|
};
|
|
|
|
template <typename T>
|
|
struct has_co_await_operator<T, std::void_t<decltype(std::declval<T>().operator co_await())>> : std::true_type {
|
|
};
|
|
|
|
template <typename T>
|
|
constexpr bool has_co_await_operator_v = has_co_await_operator<T>::value;
|
|
|
|
|
|
template <typename T, bool>
|
|
struct deduced_awaitable_ret_type;
|
|
|
|
template <typename T>
|
|
struct deduced_awaitable_ret_type<T, true> {
|
|
using type = decltype(std::declval<decltype(std::declval<T>().operator co_await())>().await_resume());
|
|
};
|
|
|
|
|
|
template <typename T>
|
|
struct deduced_awaitable_ret_type<T, false> {
|
|
using type = decltype(std::declval<T>().await_resume());
|
|
};
|
|
|
|
|
|
template <typename T>
|
|
using deduced_awaitable_ret_type_t = typename deduced_awaitable_ret_type<T, has_co_await_operator_v<T>>::type;
|
|
|
|
|
|
template <typename T, typename UT = void>
|
|
concept result_awaiter_c = requires(T t, std::coroutine_handle<> hndl) {
|
|
{ t.await_ready() } -> std::convertible_to<bool>;
|
|
|
|
// await_suspend can return void, bool, or a coroutine_handle
|
|
// t.await_suspend(hndl);
|
|
|
|
// await_resume must return the specific type UT
|
|
{ t.await_resume() } -> std::same_as<UT>;
|
|
};
|
|
|
|
|
|
template <typename T, typename UT = void>
|
|
concept result_awaitable_c = requires(T t) {
|
|
// { t.operator co_await() } -> result_awaiter_c<UT>;
|
|
t.operator co_await();
|
|
};
|
|
// template <typename T, typename UT = void>
|
|
// concept result_awaitable_c = result_awaiter_c<T, UT> || requires(T t) {
|
|
// { t.operator co_await() } -> result_awaiter_c<UT>;
|
|
// };
|
|
|
|
|
|
template <typename T>
|
|
concept awaitable_c = (!has_co_await_operator_v<T> || requires {
|
|
std::declval<decltype(std::declval<T>().operator co_await())>().await_resume();
|
|
}) && (has_co_await_operator_v<T> || requires { std::declval<T>().await_resume(); });
|
|
|
|
|
|
|
|
// template <typename T, typename RT = void>
|
|
// concept awaitable_ret_type_c =
|
|
// (!has_co_await_operator_v<T> ||
|
|
// std::same_as<decltype(std::declval<decltype(std::declval<T>().operator co_await())>().await_resume()), RT>) &&
|
|
// (has_co_await_operator_v<T> || std::same_as<decltype(std::declval<T>().await_resume()), RT>);
|
|
|
|
template <typename T, typename RT = void>
|
|
concept awaitable_ret_type_c = awaitable_c<T> && std::same_as<deduced_awaitable_ret_type_t<T>, RT>;
|
|
|
|
|
|
static_assert(awaitable_ret_type_c<asio::awaitable<void>>, "!!!");
|
|
static_assert(awaitable_c<asio::awaitable<int>>, "!!!");
|
|
|
|
template <typename T, typename RT>
|
|
concept awaitable_ret_expected_type_c = awaitable_c<T> && ret_expected_type_c<deduced_awaitable_ret_type_t<T>, RT>;
|
|
|
|
|
|
// template <typename T, typename UT = void>
|
|
// concept async_retval_c = result_awaiter_c<decltype(std::declval<T>().operator co_await()), UT>;
|
|
|
|
template <typename T, typename UT = void>
|
|
concept async_retval_c = result_awaitable_c<T, UT> && ret_expected_c<UT>;
|
|
|
|
|
|
|
|
/* a concept for generic logger class */
|
|
|
|
template <typename T>
|
|
concept logger_c = requires(T t) {
|
|
{ t.logInfo(std::declval<std::string const&>()) };
|
|
{ t.logWarn(std::declval<std::string const&>()) };
|
|
{ t.logDebug(std::declval<std::string const&>()) };
|
|
{ t.logError(std::declval<std::string const&>()) };
|
|
{ t.logTrace(std::declval<std::string const&>()) };
|
|
};
|
|
|
|
|
|
|
|
}; // namespace snplib
|