concept.h

#pragma once
 
#ifndef BOOST_HANA_CONFIG_ENABLE_STRING_UDL
#error "OZO needs BOOST_HANA_CONFIG_ENABLE_STRING_UDL to be defined"
#endif
 
#include <boost/fusion/adapted.hpp>
#include <boost/fusion/sequence.hpp>
#include <boost/fusion/support/is_sequence.hpp>
#include <boost/fusion/include/is_sequence.hpp>
#include <boost/hana/core/is_a.hpp>
#include <boost/hana/tuple.hpp>
#include <boost/hana/string.hpp>
#include <typeinfo>
#include <type_traits>
#include <iterator>
 
namespace ozo {
 
 
template <bool Condition, typename Type = void>
#ifdef OZO_DOCUMENTATION
using Require = Type;
#else
using Require = std::enable_if_t<Condition, Type>;
#endif
 
 
template <typename T, typename = std::void_t<>>
struct has_operator_not : std::false_type {};
template <typename T>
struct has_operator_not<T, std::void_t<decltype(!std::declval<T>())>>
    : std::true_type {};
 
template <typename T>
inline constexpr auto OperatorNot = has_operator_not<std::decay_t<T>>::value;
 
template <typename T, typename Enable = void>
struct is_output_iterator : std::false_type {};
 
template <typename T>
struct is_output_iterator<T, typename std::enable_if<
    std::is_base_of<
        std::output_iterator_tag,
        typename std::iterator_traits<T>::iterator_category
    >::value
>::type>
: std::true_type {};
 
template <typename T>
inline constexpr auto OutputIterator = is_output_iterator<T>::value;
 
template <typename T, typename Enable = void>
struct is_forward_iterator : std::false_type {};
 
template <typename T>
struct is_forward_iterator<T, typename std::enable_if<
    std::is_base_of<
        std::forward_iterator_tag,
        typename std::iterator_traits<T>::iterator_category
    >::value
>::type>
: std::true_type {};
 
template <typename T>
inline constexpr auto ForwardIterator = is_forward_iterator<T>::value;
 
template <typename T, typename Enable = void>
struct is_iterable : std::false_type {};
 
template <typename T>
struct is_iterable<T, typename std::enable_if<
    is_forward_iterator<decltype(begin(std::declval<T>()))>::value &&
        is_forward_iterator<decltype(end(std::declval<T>()))>::value
>::type>
: std::true_type {};
 
template <typename T>
inline constexpr auto Iterable = is_iterable<T>::value;
 
template <typename T, typename Enable = void>
struct is_insert_iterator : std::false_type {};
 
template <typename T>
struct is_insert_iterator<T, typename std::enable_if<
    is_output_iterator<T>::value && std::is_class<typename T::container_type>::value
>::type>
: std::true_type {};
 
template <typename T>
inline constexpr auto InsertIterator = is_insert_iterator<T>::value;
 
template <typename T>
inline constexpr auto FusionSequence = boost::fusion::traits::is_sequence<std::decay_t<T>>::value;
 
template <typename T>
inline constexpr auto HanaSequence = boost::hana::Sequence<std::decay_t<T>>::value;
 
template <typename T>
inline constexpr auto HanaStruct = boost::hana::Struct<std::decay_t<T>>::value;
 
template <typename T>
inline constexpr auto HanaString = decltype(boost::hana::is_a<boost::hana::string_tag>(std::declval<T>()))::value;
 
template <typename T>
inline constexpr auto HanaTuple = decltype(boost::hana::is_a<boost::hana::tuple_tag>(std::declval<T>()))::value;
 
 
template <typename T, typename = std::void_t<>>
struct is_fusion_adapted_struct : std::false_type {};
 
template <typename T>
struct is_fusion_adapted_struct<T, std::enable_if_t<
    std::is_same_v<
        typename boost::fusion::traits::tag_of<T>::type,
        boost::fusion::struct_tag
    >
>> : std::true_type {};
 
 
template <typename T>
inline constexpr auto FusionAdaptedStruct = is_fusion_adapted_struct<std::decay_t<T>>::value;
 
template <typename T>
inline constexpr auto Integral = std::is_integral_v<std::decay_t<T>>;
 
template <typename T>
inline constexpr auto FloatingPoint = std::is_floating_point_v<std::decay_t<T>>;
 
namespace detail {
 
template <typename T, typename = std::void_t<>>
struct std_size_data_compatible {
    static constexpr bool value = false;
};
 
template <typename T>
struct std_size_data_compatible<T, std::void_t<
    decltype(std::data(std::declval<T&>())+std::size(std::declval<T&>()))>
> {
    static constexpr bool value = !std::is_const_v<std::remove_pointer_t<decltype(std::data(std::declval<T&>()))>> || std::is_const_v<T>;
};
 
template <typename T, typename = std::void_t<>>
struct adl_size_data_compatible {
    static constexpr bool value = false;
};
 
template <typename T>
struct adl_size_data_compatible<T, std::void_t<
    decltype(data(std::declval<T&>())+size(std::declval<T&>()))>
> {
    static constexpr bool value = !std::is_const_v<std::remove_pointer_t<decltype(data(std::declval<T&>()))>> || std::is_const_v<T>;
};
 
template <typename T>
constexpr auto sizeof_value_type(T& v) {
    if constexpr (std_size_data_compatible<T>::value) {
        return std::integral_constant<std::size_t, sizeof(decltype(*std::data(v)))>{};
    } else if constexpr (adl_size_data_compatible<T>::value) {
        return std::integral_constant<std::size_t, sizeof(decltype(*data(v)))>{};
    } else {
        return std::integral_constant<std::size_t, 0>{};
    }
}
 
template <typename T>
constexpr std::size_t sizeof_value_type() {
    return decltype(sizeof_value_type(std::declval<T&>()))::value;
}
 
} // namespace detail
 
template <typename T>
using is_raw_data_writable = std::bool_constant<
    !std::is_const_v<T> && detail::sizeof_value_type<T>() == 1
>;
 
template <typename T>
using is_raw_data_readable = std::bool_constant<
    detail::sizeof_value_type<std::add_const_t<T>>() == 1
>;
 
template <typename T>
inline constexpr auto RawDataWritable = is_raw_data_writable<std::remove_reference_t<T>>::value;
 
template <typename T>
inline constexpr auto RawDataReadable = is_raw_data_readable<std::remove_reference_t<T>>::value;
 
template <typename T, typename = std::void_t<>>
struct is_emplaceable : std::false_type {};
 
template <typename T>
struct is_emplaceable<T, std::void_t<decltype(std::declval<T&>().emplace())>> : std::true_type {};
 
template <typename T>
inline constexpr auto Emplaceable = is_emplaceable<std::decay_t<T>>::value;
 
template <typename T>
struct is_time_constraint : std::false_type {};
 
template <typename T>
inline constexpr auto TimeConstraint = is_time_constraint<std::decay_t<T>>::value;
 
 
} // namespace ozo