concepts.h

Go to the documentation of this file.

/**
 
    @file      concepts.h
    @author    Khrapov
    @date      2.11.2021
    @copyright © Nick Khrapov, 2021. All right reserved.
 
**/
#pragma once
 
#include <type_traits>
#include <utility>
#include <variant>
 
namespace qx
{
 
// ---------------------------------------------------- std wrappers ---------------------------------------------------
 
template<class T>
concept enumeration_c = std::is_enum_v<T>;
 
template<class T>
concept arithmetic_c = std::is_arithmetic_v<T>;
 
 
 
 
template<class T>
concept is_iterator = requires(T) { typename T::iterator_category; };
 
template<class T>
concept is_random_access_iterator =
    is_iterator<T> && std::derived_from<typename T::iterator_category, std::random_access_iterator_tag>;
 
template<class T, class return_t, class... args_t>
concept callable_c = requires(T t, args_t&&... args) {
    { t(std::forward<args_t>(args)...) } -> std::convertible_to<return_t>;
};
 
// won't work for base_args_t containing template template or type template parameters
template<class derived_t, template<class... base_args_t> class base_t, class... partial_specialization_args_t>
concept derived_from_template_c = requires(const derived_t& derived) {
    []<class... base_args_t>(const base_t<partial_specialization_args_t..., base_args_t...>&)
    {
    }(derived);
};
 
namespace details
{
 
template<class range_t, class T>
concept is_iterator_arrow_operator_of_t_type = requires(range_t t) {
    { t.begin().operator->() } -> std::convertible_to<const T*>;
    { t.end().operator->() } -> std::convertible_to<const T*>;
};
 
template<class range_t, class T>
concept is_iterator_t_pointer = requires(range_t t) {
    { t.begin() } -> std::convertible_to<const T*>;
    { t.end() } -> std::convertible_to<const T*>;
};
 
} // namespace details
 
template<class range_t, class T>
concept range_of_t_c =
    details::is_iterator_arrow_operator_of_t_type<range_t, T> || details::is_iterator_t_pointer<range_t, T>;
 
 
namespace details
{
 
template<class T, class variant_t>
struct is_in_variant;
 
template<class T, class... args_t>
struct is_in_variant<T, std::variant<args_t...>> : std::disjunction<std::is_same<T, args_t>...>
{
};
 
} // namespace details
 
template<class T, class variant_t>
concept in_variant_c = details::is_in_variant<T, variant_t>::value;
 
} // namespace qx