concepts.hpp

Go to the documentation of this file.

#pragma once
 
#include <concepts>
#include <functional>
#include <memory>
#include <mutable/util/unsharable_shared_ptr.hpp>
#include <type_traits>
 
 
namespace m {
 
template<typename T>
concept boolean = std::same_as<T, bool>;
 
template<typename T>
concept character = std::same_as<T, char>;
 
template<typename T>
concept integral = (std::integral<T> and not boolean<T>);
 
template<typename T>
concept signed_integral = integral<T> and std::is_signed_v<T>;
 
template<typename T>
concept unsigned_integral = integral<T> and not std::is_signed_v<T>;
 
template<typename T>
concept arithmetic = integral<T> or std::floating_point<T>;
 
template<typename T>
concept pointer = std::is_pointer_v<T>;
 
template<typename T>
concept primitive = arithmetic<T> or boolean<T> or character<T>;
 
template<typename T>
concept pointer_to_primitive = (pointer<T> and
                                (primitive<std::remove_pointer_t<T>> or std::is_void_v<std::remove_pointer_t<T>>));
 
template<typename T>
concept decayable = not std::same_as<T, std::decay_t<T>>;
 
template<typename T, typename U>
concept same_signedness = (arithmetic<T> and arithmetic<U> and std::is_signed_v<T> == std::is_signed_v<U>) or
                          (boolean<T> and boolean<U>);
 
template<typename T, typename U>
concept equally_floating = arithmetic<T> and arithmetic<U> and
                           std::floating_point<T> == std::floating_point<U>;
 
 
template<typename T, typename U>
struct common_type;
 
template<typename T>
struct common_type<T, T>
{ using type = T; };
 
template<typename T, typename U>
requires arithmetic<T> and arithmetic<U> and same_signedness<T, U> and equally_floating<T, U>
struct common_type<T, U>
{
    using type = std::conditional_t<sizeof(T) >= sizeof(U), T, U>;
};
 
template<typename T, typename U>
requires arithmetic<T> and arithmetic<U> and same_signedness<T, U> and (not equally_floating<T, U>)
struct common_type<T, U>
{
    using type = std::conditional_t<std::is_floating_point_v<T>, T, U>;
};
 
template<typename T, typename U>
using common_type_t = typename common_type<T, U>::type;
 
template<typename T, typename U>
concept have_common_type = requires { typename common_type_t<T, U>; };
 
 
template<typename T>
concept is_unique_ptr = std::same_as<std::decay_t<T>, std::unique_ptr<typename T::element_type>>;
 
template<typename T>
concept is_unsharable_shared_ptr = std::same_as<std::decay_t<T>, unsharable_shared_ptr<typename T::element_type>>;
 
template<typename T>
concept is_reference_wrapper = std::same_as<std::decay_t<T>, std::reference_wrapper<typename T::type>>;
 
 
template<template<typename...> class Template, typename... Args>
concept is_template_instantiable = requires { typename Template<Args...>; };
 
 
namespace detail {
 
template<typename T, template<typename...> class Template>
struct is_specialization : std::false_type {};
 
template<template<typename...> class Template, typename... Args>
struct is_specialization<Template<Args...>, Template> : std::true_type {};
 
}
 
template<typename T, template <typename...> class Template>
concept is_specialization = detail::is_specialization<std::remove_cvref_t<T>, Template>::value;
 
 
template<typename... Ts>
struct param_pack_t : std::tuple<Ts...> {};
 
namespace detail {
 
template<typename T>
struct is_param_pack : std::false_type {};
 
template<typename... Ts>
struct is_param_pack<param_pack_t<Ts...>> : std::true_type {};
 
template<typename T>
constexpr bool is_param_pack_v = is_param_pack<T>::value;
 
template<typename T>
struct as_tuple;
 
template<typename... Ts>
struct as_tuple<param_pack_t<Ts...>>
{
    using type = std::tuple<Ts...>;
};
 
template<typename T>
using as_tuple_t = typename as_tuple<T>::type;
 
}
 
template<typename T>
concept param_pack = detail::is_param_pack_v<T>;
 
template<param_pack P>
constexpr std::size_t param_pack_size_v = std::tuple_size_v<detail::as_tuple_t<P>>;
 
template<std::size_t I, param_pack P>
using param_pack_element_t = std::tuple_element_t<I, detail::as_tuple_t<P>>;
 
namespace detail {
 
template<param_pack P, typename T>
struct typed_param_pack_helper
{
    template<std::size_t... Is>
    requires (sizeof...(Is) == param_pack_size_v<P>) and (std::same_as<param_pack_element_t<Is, P>, T> and ...)
    typed_param_pack_helper(std::index_sequence<Is...>) { }
};
 
}
 
template<typename P, typename T>
concept typed_param_pack = requires {
    detail::typed_param_pack_helper<P, T>(std::make_index_sequence<param_pack_size_v<P>>{});
};
 
template<typename P>
concept size_param_pack = typed_param_pack<P, std::size_t>;
 
template<typename Stream, typename T>
concept streamable = requires (Stream &out, const T &t) {
    { out << t } -> std::same_as<Stream&>;
};
 
template<typename Callback, typename T>
concept is_invocable = requires (Callback &&callback, T value) {
    std::invoke(std::forward<Callback>(callback), value);
};
 
}