Constraints.h

#pragma once
 
#include <type_traits>
#include <functional>
 
namespace CXXIter::util {
    namespace {
 
        template <class T, class... Ts>
        constexpr bool are_same_v = (std::is_same_v<T, Ts> && ...);
 
        template <typename T, template <typename> typename U>
        constexpr bool is_template_instance_v = false;
        template <typename T, template <typename> typename U>
        constexpr bool is_template_instance_v<U<T>, U> = true;
 
 
        template<typename T>
        concept is_hashable = requires(T a) {
            { std::hash<T>{}(a) } -> std::convertible_to<std::size_t>;
        };
 
        template<typename TFn, typename... TArgs>
        concept invocable_byvalue = requires(TFn fn, TArgs... args) {
            { fn(args...) }; // disallows TArgs&&
            { fn(std::forward<TArgs>(args)...) }; // disallows TArgs&
        };
 
        template<typename T>
        inline constexpr bool is_const_reference_v = std::is_const_v<std::remove_reference_t<T>>;
 
        template<typename T> concept is_pair = requires(T pair) {
            {std::get<0>(pair)} -> std::convertible_to< std::tuple_element_t<0, T> >;
            {std::get<1>(pair)} -> std::convertible_to< std::tuple_element_t<1, T> >;
        } && std::tuple_size_v<T> == 2;
 
        template<typename T> concept is_optional = requires(T optional, typename T::value_type value) {
            typename T::value_type;
            {optional.value()} -> std::convertible_to<typename T::value_type>;
            {optional.value_or(value)} -> std::convertible_to<typename T::value_type>;
            {optional = value};
        };
 
 
        // ################################################################################################
        // CONTAINER CONSTRAINTS
        // ################################################################################################
 
        template<typename TContainer>
        concept ReservableContainer = requires(TContainer container, size_t newSize) {
            container.reserve(newSize);
        };
 
        template<typename TContainer, typename TItem>
        concept BackInsertableContainer = requires(TContainer& container, TItem item) {
            typename TContainer::value_type;
            container.push_back(item);
        };
 
        template<template<typename...> typename TContainer, typename TItem, typename... TContainerArgs>
        concept BackInsertableContainerTemplate = BackInsertableContainer<TContainer<TItem, TContainerArgs...>, TItem>;
 
 
        template<typename TContainer, typename TItem>
        concept InsertableContainer = requires(TContainer& container, TItem item) {
            typename TContainer::value_type;
            container.insert(item);
        };
        template<template<typename...> typename TContainer, typename TItem, typename... TContainerArgs>
        concept InsertableContainerTemplate = InsertableContainer<TContainer<TItem, TContainerArgs...>, TItem>;
 
        template<typename TContainer, typename TItemKey, typename TItemValue>
        concept AssocContainer = requires(TContainer& container, std::pair<TItemKey, TItemValue> item) {
            typename TContainer::value_type;
            typename TContainer::key_type;
            typename TContainer::mapped_type;
            container.insert(item);
        };
        template<template<typename...> typename TContainer, typename TItemKey, typename TItemValue, typename... TContainerArgs>
        concept AssocContainerTemplate = AssocContainer<TContainer<TItemKey, TItemValue, TContainerArgs...>, TItemKey, TItemValue>;
 
        template<typename TContainer, typename TItem>
        concept StdArrayContainer = requires(TContainer& container, size_t idx, TItem item) {
            typename TContainer::value_type;
            typename TContainer::size_type;
            {container[idx] = item};
            {container.max_size()} -> std::same_as<typename TContainer::size_type>;
            {container.fill(item)};
        } && !InsertableContainer<TContainer, TItem> && !BackInsertableContainer<TContainer, TItem>;
 
        template<typename TContainer>
        concept ContiguousMemoryContainer = requires(TContainer& container) {
            typename TContainer::value_type;
            typename TContainer::size_type;
            {container.data()} -> std::same_as<typename TContainer::value_type*>;
        };
 
    }
}