Skip to content
Permalink
027ae81e75
Switch branches/tags

kfr/include/kfr/cometa.hpp

Go to file
 
 
Cannot retrieve contributors at this time
2024 lines (1714 sloc) 58.5 KB
Raw Blame
/** @addtogroup cometa
* @{
*/
#pragma once
#include "cident.h"
#include <algorithm>
#include <array>
#include <tuple>
#include <type_traits>
#include <vector>
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wshadow"
namespace cometa
{
using std::size_t;
using std::ptrdiff_t;
using pvoid = void*;
template <typename...>
using void_t = void;
// Workaround for GCC 4.8
template <typename T>
constexpr const T& const_max(const T& x, const T& y)
{
return x > y ? x : y;
}
template <typename T>
constexpr const T& const_min(const T& x, const T& y)
{
return x < y ? x : y;
}
namespace details
{
constexpr inline bool args_or() { return false; }
template <typename... Ts>
constexpr inline bool args_or(bool x, Ts... rest)
{
return x || args_or(rest...);
}
constexpr inline bool args_and() { return true; }
template <typename... Ts>
constexpr inline bool args_and(bool x, Ts... rest)
{
return x && args_and(rest...);
}
template <typename T, typename Enable = void>
struct is_pod_impl : std::false_type
{
};
template <typename T>
struct is_pod_impl<T, void_t<decltype(T::is_pod)>> : std::integral_constant<bool, T::is_pod>
{
};
}
template <typename... Ts>
struct or_t : std::integral_constant<bool, details::args_or(Ts::value...)>
{
};
template <typename... Ts>
struct and_t : std::integral_constant<bool, details::args_and(Ts::value...)>
{
};
template <typename T>
struct not_t : std::integral_constant<bool, !T::value>
{
};
constexpr size_t max_size_t = size_t(-1);
template <typename... T>
using common_type = typename std::common_type<T...>::type;
template <typename T>
using result_of = typename std::result_of<T>::type;
template <bool Condition, typename Type = void>
using enable_if = typename std::enable_if<Condition, Type>::type;
template <bool Condition, typename T, typename F>
using conditional = typename std::conditional<Condition, T, F>::type;
template <typename T>
using remove_reference = typename std::remove_reference<T>::type;
template <typename T>
using remove_cv = typename std::remove_cv<T>::type;
template <typename T>
using remove_pointer = typename std::remove_pointer<T>::type;
template <typename T>
using remove_extent = typename std::remove_extent<T>::type;
template <typename T>
using remove_const = typename std::remove_const<T>::type;
template <typename T>
using underlying_type = typename std::underlying_type<T>::type;
template <typename T>
using is_pod = or_t<std::is_pod<T>, details::is_pod_impl<T>>;
template <typename T>
using is_class = std::is_class<T>;
template <typename T>
using is_const = std::is_const<T>;
template <typename T>
using is_pointer = std::is_pointer<T>;
template <typename T>
using is_array = std::is_array<T>;
template <typename T>
using is_void = std::is_void<T>;
template <typename T1, typename T2>
using is_same = std::is_same<T1, T2>;
template <typename T>
using is_template_arg = std::integral_constant<bool, std::is_integral<T>::value || std::is_enum<T>::value>;
template <typename T>
using decay = typename std::decay<T>::type;
template <typename... T>
using decay_common = decay<common_type<T...>>;
template <typename T1, typename T2 = void, typename... Ts>
constexpr size_t typeindex()
{
return is_same<T1, T2>() ? 0 : 1 + typeindex<T1, Ts...>();
}
template <typename T>
struct compound_type_traits
{
constexpr static size_t width = 1;
constexpr static size_t deep_width = width;
using subtype = T;
using deep_subtype = T;
constexpr static size_t depth = 0;
constexpr static bool is_scalar = true;
template <typename U>
using rebind = U;
template <typename U>
using deep_rebind = U;
CMT_INLINE static constexpr const subtype& at(const T& value, size_t /*index*/) { return value; }
};
template <typename T>
using is_compound = std::integral_constant<bool, !compound_type_traits<decay<T>>::is_scalar>;
template <typename T>
using subtype = typename compound_type_traits<T>::subtype;
template <typename T>
using deep_subtype = typename compound_type_traits<T>::deep_subtype;
template <typename T, typename SubType>
using rebind_subtype = typename compound_type_traits<T>::template rebind<SubType>;
template <typename T, typename SubType>
using deep_rebind = typename compound_type_traits<T>::template deep_rebind<SubType>;
template <typename T>
struct compound_type_traits<std::pair<T, T>>
{
constexpr static size_t width = 2;
constexpr static size_t deep_width = width * compound_type_traits<T>::width;
using subtype = T;
using deep_subtype = cometa::deep_subtype<T>;
constexpr static bool is_scalar = false;
constexpr static size_t depth = cometa::compound_type_traits<T>::depth + 1;
template <typename U>
using rebind = std::pair<U, U>;
template <typename U>
using deep_rebind = std::pair<cometa::deep_rebind<subtype, U>, cometa::deep_rebind<subtype, U>>;
CMT_INLINE static constexpr const subtype& at(const std::pair<subtype, subtype>& value, size_t index)
{
return index == 0 ? value.first : value.second;
}
};
namespace ops
{
struct empty
{
};
}
template <typename T, T val>
struct cval_t : ops::empty
{
constexpr static T value = val;
constexpr cval_t() noexcept = default;
constexpr cval_t(const cval_t&) noexcept = default;
constexpr cval_t(cval_t&&) noexcept = default;
typedef T value_type;
typedef cval_t type;
constexpr operator value_type() const { return value; }
constexpr value_type operator()() const { return value; }
};
template <typename T, T value>
constexpr inline T val_of(cval_t<T, value>)
{
return value;
}
template <typename T>
constexpr inline T val_of(T value)
{
return value;
}
template <typename T>
constexpr inline bool is_constant_val(T)
{
return false;
}
template <typename T, T value>
constexpr inline bool is_constant_val(cval_t<T, value>)
{
return true;
}
namespace details
{
template <typename T>
struct inherit : T
{
};
template <typename T, typename Enable = void>
struct is_inheritable_impl : std::false_type
{
};
template <typename T>
struct is_inheritable_impl<T, void_t<inherit<T>>> : std::true_type
{
};
template <typename T>
struct is_val_impl : std::false_type
{
};
template <typename T, T val>
struct is_val_impl<cval_t<T, val>> : std::true_type
{
};
}
template <typename T>
using is_inheritable = typename details::is_inheritable_impl<T>::type;
template <typename T>
using is_val_t = typename details::is_val_impl<T>::type;
template <bool val>
using cbool_t = cval_t<bool, val>;
template <int val>
using cint_t = cval_t<int, val>;
template <unsigned val>
using cuint_t = cval_t<unsigned, val>;
template <size_t val>
using csize_t = cval_t<size_t, val>;
template <typename T, T val>
constexpr cval_t<T, val> cval{};
template <bool val>
constexpr cbool_t<val> cbool{};
using cfalse_t = cbool_t<false>;
using ctrue_t = cbool_t<true>;
constexpr ctrue_t ctrue{};
constexpr cfalse_t cfalse{};
template <int val>
constexpr cint_t<val> cint{};
template <unsigned val>
constexpr cuint_t<val> cuint{};
template <size_t val>
constexpr csize_t<val> csize{};
namespace details
{
template <size_t index, typename T, T first, T... rest>
struct get_nth : get_nth<index - 1, T, rest...>
{
};
template <typename T, T first, T... rest>
struct get_nth<0, T, first, rest...>
{
constexpr static T value = first;
};
template <size_t index, typename... Types>
struct get_nth_type;
template <size_t index, typename first, typename... rest>
struct get_nth_type<index, first, rest...> : get_nth_type<index - 1, rest...>
{
};
template <typename first, typename... rest>
struct get_nth_type<0, first, rest...>
{
using type = first;
};
template <size_t index>
struct get_nth_type<index>
{
};
}
template <typename T, T... values>
struct cvals_t : ops::empty
{
using type = cvals_t<T, values...>;
constexpr static size_t size() { return sizeof...(values); }
template <size_t index>
constexpr T operator[](csize_t<index>)
{
return get(csize<index>);
}
template <size_t index>
constexpr static T get(csize_t<index> = csize_t<index>())
{
return details::get_nth<index, T, values...>::value;
}
constexpr static T front() { return get(csize<0>); }
constexpr static T back() { return get(csize<size() - 1>); }
static const T* begin() { return array(); }
static const T* end() { return array() + size(); }
static const T* array()
{
static const T arr[] = { values... };
return &arr[0];
}
template <size_t... indices>
constexpr cvals_t<T, details::get_nth<indices, T, values...>::value...> operator[](
cvals_t<size_t, indices...>) const
{
return {};
}
};
template <typename T>
struct cvals_t<T> : ops::empty
{
using type = cvals_t<T>;
constexpr static size_t size() { return 0; }
};
template <bool... values>
using cbools_t = cvals_t<bool, values...>;
template <int... values>
using cints_t = cvals_t<int, values...>;
template <char... values>
using cchars_t = cvals_t<char, values...>;
template <unsigned... values>
using cuints_t = cvals_t<unsigned, values...>;
template <size_t... values>
using csizes_t = cvals_t<size_t, values...>;
template <size_t... values>
using elements_t = cvals_t<size_t, values...>;
template <typename T, T... values>
constexpr cvals_t<T, values...> cvals{};
template <bool... vals>
constexpr cbools_t<vals...> cbools{};
constexpr cbools_t<false, true> cfalse_true{};
template <int... vals>
constexpr cints_t<vals...> cints{};
template <char... vals>
constexpr cchars_t<vals...> cchars{};
template <unsigned... vals>
constexpr cuints_t<vals...> cuints{};
template <size_t... vals>
constexpr csizes_t<vals...> csizes{};
template <size_t... vals>
constexpr elements_t<vals...> elements{};
template <typename T>
constexpr inline T csum(cvals_t<T>)
{
return 0;
}
template <typename T, T first, T... rest>
constexpr inline T csum(cvals_t<T, first, rest...>)
{
return first + csum(cvals<T, rest...>);
}
template <typename T>
constexpr inline T cprod(cvals_t<T>)
{
return 1;
}
template <typename T, T first, T... rest>
constexpr inline T cprod(cvals_t<T, first, rest...>)
{
return first * cprod(cvals<T, rest...>);
}
template <typename T>
struct ctype_t
{
using type = T;
};
template <typename T>
using type_of = typename T::type;
template <typename T>
constexpr ctype_t<T> ctype{};
template <typename... Types>
struct ctypes_t
{
constexpr static size_t size() { return sizeof...(Types); }
template <size_t index>
using nth = typename details::get_nth_type<index, Types...>::type;
template <size_t index>
constexpr static auto get(csize_t<index>) -> ctype_t<nth<index>>
{
return {};
}
};
template <typename... Ts>
constexpr ctypes_t<Ts...> ctypes{};
namespace details
{
template <typename T1, typename T2>
struct concat_impl;
template <typename T, T... values1, T... values2>
struct concat_impl<cvals_t<T, values1...>, cvals_t<T, values2...>>
{
using type = cvals_t<T, values1..., values2...>;
};
template <typename... types1, typename... types2>
struct concat_impl<ctypes_t<types1...>, ctypes_t<types2...>>
{
using type = ctypes_t<types1..., types2...>;
};
}
template <typename T1, typename T2>
using concat_lists = typename details::concat_impl<T1, T2>::type;
template <typename T1, typename T2>
constexpr inline concat_lists<T1, T2> cconcat(T1, T2)
{
return {};
}
namespace details
{
template <typename>
struct function_arguments_impl;
template <typename Ret, typename... Args>
struct function_arguments_impl<Ret (*)(Args...)>
{
using result = Ret;
using args = ctypes_t<Args...>;
};
template <typename Class, typename Ret, typename... Args>
struct function_arguments_impl<Ret (Class::*)(Args...)>
{
using result = Ret;
using args = ctypes_t<Args...>;
};
template <typename Class, typename Ret, typename... Args>
struct function_arguments_impl<Ret (Class::*)(Args...) const>
{
using result = Ret;
using args = ctypes_t<Args...>;
};
template <typename T1, typename T2>
struct filter_impl;
template <typename T>
struct filter_impl<cvals_t<T>, cvals_t<bool>>
{
using type = cvals_t<T>;
};
template <typename T, T value, T... values, bool flag, bool... flags>
struct filter_impl<cvals_t<T, value, values...>, cvals_t<bool, flag, flags...>>
{
using filtered = typename filter_impl<cvals_t<T, values...>, cvals_t<bool, flags...>>::type;
using type = conditional<flag, concat_lists<cvals_t<T, value>, filtered>, filtered>;
};
}
template <typename Fn>
using function_arguments = typename details::function_arguments_impl<decltype(&Fn::operator())>::args;
template <typename Fn>
using function_result = typename details::function_arguments_impl<decltype(&Fn::operator())>::result;
template <typename T1, typename T2>
using cfilter_t = typename details::filter_impl<T1, T2>::type;
template <typename T, T... vals, bool... flags,
typename Ret = cfilter_t<cvals_t<T, vals...>, cvals_t<bool, flags...>>>
constexpr inline Ret cfilter(cvals_t<T, vals...>, cvals_t<bool, flags...>)
{
return Ret{};
}
#define CMT_UN_OP(op) \
template <typename T1, T1... vals1, \
typename Ret = cvals_t<decltype(op std::declval<T1>()), (op vals1)...>> \
constexpr inline Ret operator op(cvals_t<T1, vals1...>) \
{ \
return Ret{}; \
} \
template <typename T1, T1 val1, typename Ret = cval_t<decltype(op std::declval<T1>()), (op val1)>> \
constexpr inline Ret operator op(cval_t<T1, val1>) \
{ \
return Ret{}; \
}
#define CMT_BIN_OP(op) \
template <typename T1, T1... vals1, typename T2, T2... vals2, \
typename Ret = \
cvals_t<decltype(std::declval<T1>() op std::declval<T2>()), (vals1 op vals2)...>> \
constexpr inline Ret operator op(cvals_t<T1, vals1...>, cvals_t<T2, vals2...>) \
{ \
return Ret{}; \
} \
template <typename T1, T1... vals1, typename T2, T2 val2, \
typename Ret = \
cvals_t<decltype(std::declval<T1>() op std::declval<T2>()), (vals1 op val2)...>> \
constexpr inline Ret operator op(cvals_t<T1, vals1...>, cval_t<T2, val2>) \
{ \
return Ret{}; \
} \
template <typename T1, T1 val1, typename T2, T2... vals2, \
typename Ret = \
cvals_t<decltype(std::declval<T1>() op std::declval<T2>()), (val1 op vals2)...>> \
constexpr inline Ret operator op(cval_t<T1, val1>, cvals_t<T2, vals2...>) \
{ \
return Ret{}; \
}
namespace ops
{
// clang-format off
CMT_UN_OP(-)
CMT_UN_OP(+)
CMT_UN_OP(~)
CMT_UN_OP(!)
CMT_BIN_OP(&&)
CMT_BIN_OP(||)
CMT_BIN_OP(==)
CMT_BIN_OP(!=)
CMT_BIN_OP(<)
CMT_BIN_OP(>)
CMT_BIN_OP(<=)
CMT_BIN_OP(>=)
CMT_BIN_OP(+)
CMT_BIN_OP(-)
CMT_BIN_OP(*)
CMT_BIN_OP(/)
CMT_BIN_OP(%)
CMT_BIN_OP(<<)
CMT_BIN_OP(>>)
CMT_BIN_OP(&)
CMT_BIN_OP(|)
CMT_BIN_OP(^)
// clang-format on
}
namespace details
{
template <typename T, size_t Nsize, T Nstart, ptrdiff_t Nstep>
struct cvalseq_impl;
template <typename T, size_t Nsize, T Nstart, ptrdiff_t Nstep>
using cgen_seq = typename cvalseq_impl<T, Nsize, Nstart, Nstep>::type;
template <typename T, size_t Nsize, T Nstart, ptrdiff_t Nstep>
struct cvalseq_impl : concat_impl<cgen_seq<T, Nsize / 2, Nstart, Nstep>,
cgen_seq<T, Nsize - Nsize / 2, Nstart + (Nsize / 2) * Nstep, Nstep>>
{
};
template <typename T, T Nstart, ptrdiff_t Nstep>
struct cvalseq_impl<T, 0, Nstart, Nstep> : cvals_t<T>
{
};
template <typename T, T Nstart, ptrdiff_t Nstep>
struct cvalseq_impl<T, 1, Nstart, Nstep> : cvals_t<T, static_cast<T>(Nstart)>
{
};
}
template <typename T, size_t size, T start = T(), ptrdiff_t step = 1>
using cvalseq_t = typename details::cvalseq_impl<T, size, start, step>::type;
template <typename T, T begin, T end>
constexpr cvalseq_t<T, end - begin, begin> cvalrange{};
template <size_t begin, size_t end>
constexpr cvalseq_t<size_t, end - begin, begin> csizerange{};
template <int begin, int end>
constexpr cvalseq_t<int, end - begin, begin> cintrange{};
template <unsigned begin, unsigned end>
constexpr cvalseq_t<unsigned, end - begin, begin> cuintrange{};
template <typename T, size_t size, T start = T(), ptrdiff_t step = 1>
constexpr cvalseq_t<T, size, start, step> cvalseq{};
template <size_t size, size_t start = 0, ptrdiff_t step = 1>
constexpr cvalseq_t<size_t, size, start, step> csizeseq{};
template <size_t size, int start = 0, ptrdiff_t step = 1>
constexpr cvalseq_t<int, size, start, step> cintseq{};
template <size_t size, unsigned start = 0, ptrdiff_t step = 1>
constexpr cvalseq_t<unsigned, size, start, step> cuintseq{};
template <typename... List>
using indicesfor_t = cvalseq_t<size_t, sizeof...(List), 0>;
template <typename... List>
constexpr indicesfor_t<List...> indicesfor{};
namespace details
{
template <typename Ret, typename T, typename enable = void_t<>>
struct is_returning_type_impl : std::false_type
{
};
template <typename Ret, typename Fn, typename... Args>
struct is_returning_type_impl<Ret, Fn(Args...), void_t<result_of<Fn(Args...)>>>
: std::is_same<Ret, result_of<Fn(Args...)>>
{
};
template <typename Fn, typename Args, typename enable = void_t<>>
struct is_callable_impl : std::false_type
{
};
template <typename Fn, typename... Args>
struct is_callable_impl<Fn, ctypes_t<Args...>, void_t<result_of<Fn(Args...)>>> : std::true_type
{
};
template <typename T, typename enable = void_t<>>
struct is_enabled_impl : std::true_type
{
};
template <typename Fn>
struct is_enabled_impl<Fn, void_t<decltype(Fn::disabled)>> : std::integral_constant<bool, !Fn::disabled>
{
};
template <size_t N>
struct unique_enum_impl
{
enum class type : size_t
{
value = N
};
};
template <size_t N>
using unique_enum = typename unique_enum_impl<N>::type;
#define CMT_ENABLE_IF_IMPL(N, ...) \
typename ::std::enable_if<(__VA_ARGS__), ::cometa::details::unique_enum<N>>::type = \
::cometa::details::unique_enum<N>::value
#define CMT_ENABLE_IF(...) CMT_ENABLE_IF_IMPL(__LINE__, __VA_ARGS__)
}
template <typename T>
struct is_enabled : details::is_enabled_impl<T>
{
};
template <typename Fn, typename... Args>
struct is_callable : details::is_callable_impl<Fn, ctypes_t<Args...>>
{
};
template <typename Ret, typename T>
struct is_returning_type : details::is_returning_type_impl<Ret, T>
{
};
namespace details
{
template <typename Fn, CMT_ENABLE_IF(is_callable<Fn()>())>
inline auto call_if_callable(Fn&& fn)
{
return fn();
}
template <typename Fn, CMT_ENABLE_IF(!is_callable<Fn()>())>
inline auto call_if_callable(Fn&& fn)
{
return std::forward<Fn>(fn);
}
}
template <typename Fn, typename... Args>
inline auto bind_func(Fn&& fn, Args&&... args)
{
return [=]() CMT_INLINE_LAMBDA { return fn(details::call_if_callable(std::forward<Args>(args))...); };
}
template <typename T>
constexpr inline bool is_even(T x)
{
return (x % 2) == 0;
}
template <typename T>
constexpr inline bool is_odd(T x)
{
return !is_even(x);
}
template <typename T>
constexpr inline bool is_poweroftwo(T x)
{
return ((x != 0) && !(x & (x - 1)));
}
template <typename T>
constexpr inline unsigned ilog2(T n, unsigned p = 0)
{
return (n <= 1) ? p : ilog2(n / 2, p + 1);
}
template <typename T>
constexpr inline T next_poweroftwo(T n)
{
return n > 2 ? T(1) << (ilog2(n - 1) + 1) : n;
}
template <typename T>
constexpr inline T prev_poweroftwo(T n)
{
return n > 2 ? T(1) << (ilog2(n)) : n;
}
template <typename T>
constexpr inline bool is_divisible(T x, T divisor)
{
return x % divisor == 0;
}
template <typename T>
constexpr inline T gcd(T a)
{
return a;
}
template <typename T>
constexpr inline T gcd(T a, T b)
{
return a < b ? gcd(b, a) : ((a % b == 0) ? b : gcd(b, a % b));
}
template <typename T, typename... Ts>
constexpr inline T gcd(T a, T b, T c, Ts... rest)
{
return gcd(a, gcd(b, c, rest...));
}
template <typename T>
constexpr inline T lcm(T a)
{
return a;
}
template <typename T>
constexpr inline T lcm(T a, T b)
{
return a * b / gcd(a, b);
}
template <typename T, typename... Ts>
constexpr inline T lcm(T a, T b, T c, Ts... rest)
{
return lcm(a, lcm(b, c, rest...));
}
namespace details
{
template <int64_t min, int64_t max, typename... Types>
struct findinttype_impl
{
};
template <int64_t min, int64_t max, typename T, typename... Types>
struct findinttype_impl<min, max, T, Types...>
{
using type = conditional<(std::numeric_limits<T>::min() <= min && std::numeric_limits<T>::max() >= max),
T, typename findinttype_impl<min, max, Types...>::type>;
};
template <int64_t min, int64_t max>
struct findinttype_impl<min, max>
{
using type = void;
};
template <typename T>
using is_number_impl =
std::integral_constant<bool, ((std::is_integral<T>::value) || (std::is_floating_point<T>::value)) &&
!std::is_same<T, bool>::value>;
}
template <int64_t min, int64_t max>
using findinttype = typename details::findinttype_impl<min, max, uint8_t, int8_t, uint16_t, int16_t, uint32_t,
int32_t, uint64_t, int64_t>::type;
template <typename T>
using is_number = details::is_number_impl<decay<T>>;
template <typename... Ts>
using is_numbers = and_t<details::is_number_impl<decay<Ts>>...>;
namespace details
{
template <typename T>
struct identity_impl
{
using type = T;
};
template <typename T>
constexpr size_t elementsize = sizeof(T);
template <>
constexpr size_t elementsize<void> = 1;
}
template <typename T>
using identity = typename details::identity_impl<T>::type;
struct swallow
{
template <typename... T>
CMT_INTRIN constexpr swallow(T&&...) noexcept
{
}
};
template <typename T, size_t N>
struct carray;
template <typename T>
struct carray<T, 1>
{
CMT_INTRIN constexpr carray() noexcept = default;
CMT_INTRIN constexpr carray(T val) noexcept : val(val) {}
template <typename Fn, size_t index = 0, CMT_ENABLE_IF(is_callable<Fn, csize_t<index>>::value)>
CMT_INTRIN constexpr carray(Fn&& fn, csize_t<index> = csize_t<index>{}) noexcept
: val(static_cast<T>(fn(csize<index>)))
{
}
CMT_INTRIN constexpr carray(const carray&) noexcept = default;
CMT_INTRIN constexpr carray(carray&&) noexcept = default;
CMT_INTRIN static constexpr size_t size() noexcept { return 1; }
template <size_t index>
CMT_INTRIN constexpr T& get(csize_t<index>) noexcept
{
static_assert(index == 0, "carray: Array index is out of range");
return val;
}
template <size_t index>
CMT_INTRIN constexpr const T& get(csize_t<index>) const noexcept
{
static_assert(index == 0, "carray: Array index is out of range");
return val;
}
template <size_t index>
CMT_INTRIN constexpr T& get() noexcept
{
return get(csize<index>);
}
template <size_t index>
CMT_INTRIN constexpr const T& get() const noexcept
{
return get(csize<index>);
}
CMT_INTRIN constexpr const T* front() const noexcept { return val; }
CMT_INTRIN constexpr T* front() noexcept { return val; }
CMT_INTRIN constexpr const T* back() const noexcept { return val; }
CMT_INTRIN constexpr T* back() noexcept { return val; }
CMT_INTRIN constexpr const T* begin() const noexcept { return &val; }
CMT_INTRIN constexpr const T* end() const noexcept { return &val + 1; }
CMT_INTRIN constexpr T* begin() noexcept { return &val; }
CMT_INTRIN constexpr T* end() noexcept { return &val + 1; }
CMT_INTRIN constexpr const T* data() const noexcept { return begin(); }
CMT_INTRIN constexpr T* data() noexcept { return begin(); }
CMT_INTRIN constexpr bool empty() const noexcept { return false; }
T val;
};
template <typename T, size_t N>
struct carray : carray<T, N - 1>
{
template <typename... Ts>
CMT_INTRIN constexpr carray(T first, Ts... list) noexcept : carray<T, N - 1>(list...), val(first)
{
static_assert(sizeof...(list) + 1 == N, "carray: Argument count is invalid");
}
template <typename Fn, size_t index = N - 1>
CMT_INTRIN constexpr carray(Fn&& fn, csize_t<index> = csize_t<index>{}) noexcept
: carray<T, N - 1>(std::forward<Fn>(fn), csize<index - 1>),
val(static_cast<T>(fn(csize<index>)))
{
}
CMT_INTRIN constexpr carray() noexcept = default;
CMT_INTRIN constexpr carray(const carray&) noexcept = default;
CMT_INTRIN constexpr carray(carray&&) noexcept = default;
CMT_INTRIN static constexpr size_t size() noexcept { return N; }
CMT_INTRIN constexpr T& get(csize_t<N - 1>) noexcept { return val; }
template <size_t index>
CMT_INTRIN constexpr T& get(csize_t<index>) noexcept
{
return carray<T, N - 1>::get(csize<index>);
}
CMT_INTRIN constexpr const T& get(csize_t<N - 1>) const noexcept { return val; }
template <size_t index>
CMT_INTRIN constexpr const T& get(csize_t<index>) const noexcept
{
return carray<T, N - 1>::get(csize<index>);
}
template <size_t index>
CMT_INTRIN constexpr T& get() noexcept
{
return get(csize<index>);
}
template <size_t index>
CMT_INTRIN constexpr const T& get() const noexcept
{
return get(csize<index>);
}
CMT_INTRIN constexpr const T* front() const noexcept { return carray<T, N - 1>::front(); }
CMT_INTRIN constexpr T* front() noexcept { return carray<T, N - 1>::front(); }
CMT_INTRIN constexpr const T* back() const noexcept { return val; }
CMT_INTRIN constexpr T* back() noexcept { return val; }
CMT_INTRIN constexpr const T* begin() const noexcept { return carray<T, N - 1>::begin(); }
CMT_INTRIN constexpr const T* end() const noexcept { return &val + 1; }
CMT_INTRIN constexpr T* begin() noexcept { return carray<T, N - 1>::begin(); }
CMT_INTRIN constexpr T* end() noexcept { return &val + 1; }
CMT_INTRIN constexpr const T* data() const noexcept { return begin(); }
CMT_INTRIN constexpr T* data() noexcept { return begin(); }
CMT_INTRIN constexpr bool empty() const noexcept { return false; }
private:
T val;
};
#define CMT_FN(fn) \
struct fn_##fn \
{ \
template <typename... Args> \
CMT_INLINE_MEMBER decltype(fn(std::declval<Args>()...)) operator()(Args&&... args) const \
{ \
return fn(std::forward<Args>(args)...); \
} \
};
#define CMT_ESC(...) __VA_ARGS__
#define CMT_FN_TPL(tpl_list, tpl_args, fn) \
template <CMT_ESC tpl_list> \
struct fn_##fn \
{ \
template <typename... Args> \
CMT_INLINE_MEMBER decltype(fn<CMT_ESC tpl_args>(std::declval<Args>()...)) operator()( \
Args&&... args) const \
{ \
return fn<CMT_ESC tpl_args>(std::forward<Args>(args)...); \
} \
};
template <typename T>
CMT_INTRIN auto pass_through(T&& x) noexcept
{
return x;
}
template <typename... Ts>
CMT_INTRIN void noop(Ts...) noexcept
{
}
template <typename T1, typename... Ts>
CMT_INTRIN constexpr T1&& get_first(T1&& x, Ts...) noexcept
{
return std::forward<T1>(x);
}
template <typename T1, typename T2, typename... Ts>
CMT_INTRIN constexpr T2&& get_second(T1, T2&& x, Ts...) noexcept
{
return std::forward<T2>(x);
}
template <typename T1, typename T2, typename T3, typename... Ts>
CMT_INTRIN constexpr T3&& get_third(T1, T2, T3&& x, Ts...) noexcept
{
return std::forward<T3>(x);
}
template <typename T, typename... Ts>
CMT_INTRIN constexpr T returns(Ts...)
{
return T();
}
CMT_FN(pass_through)
CMT_FN(noop)
CMT_FN(get_first)
CMT_FN(get_second)
CMT_FN(get_third)
CMT_FN_TPL((typename T), (T), returns)
template <typename T1, typename T2>
CMT_INTRIN bool is_equal(const T1& x, const T2& y)
{
return x == y;
}
template <typename T1, typename T2>
CMT_INTRIN bool is_notequal(const T1& x, const T2& y)
{
return x != y;
}
template <typename T1, typename T2>
CMT_INTRIN bool is_less(const T1& x, const T2& y)
{
return x < y;
}
template <typename T1, typename T2>
CMT_INTRIN bool is_greater(const T1& x, const T2& y)
{
return x > y;
}
template <typename T1, typename T2>
CMT_INTRIN bool is_lessorequal(const T1& x, const T2& y)
{
return x <= y;
}
template <typename T1, typename T2>
CMT_INTRIN bool is_greaterorequal(const T1& x, const T2& y)
{
return x >= y;
}
CMT_FN(is_equal)
CMT_FN(is_notequal)
CMT_FN(is_less)
CMT_FN(is_greater)
CMT_FN(is_lessorequal)
CMT_FN(is_greaterorequal)
namespace details
{
template <typename, typename = void>
struct has_begin_end_impl : std::false_type
{
};
template <typename T>
struct has_begin_end_impl<T, void_t<decltype(std::declval<T>().begin()), decltype(std::declval<T>().end())>>
: std::true_type
{
};
template <typename, typename = void>
struct has_value_type_impl : std::false_type
{
};
template <typename T>
struct has_value_type_impl<T, void_t<typename T::value_type>> : std::true_type
{
};
template <typename, typename = void>
struct has_data_size_impl : std::false_type
{
};
template <typename T>
struct has_data_size_impl<T, void_t<decltype(std::declval<T>().size()), decltype(std::declval<T>().data())>>
: std::true_type
{
};
template <typename, typename Fallback, typename = void>
struct value_type_impl
{
using type = Fallback;
};
template <typename T, typename Fallback>
struct value_type_impl<T, Fallback, void_t<typename T::value_type>>
{
using type = typename T::value_type;
};
}
template <typename T>
using has_begin_end = details::has_begin_end_impl<decay<T>>;
template <typename T>
using has_data_size = details::has_data_size_impl<decay<T>>;
template <typename T>
using value_type_of = typename decay<T>::value_type;
template <typename T, T... values, typename Fn>
CMT_INTRIN void cforeach(cvals_t<T, values...>, Fn&& fn)
{
swallow{ (fn(cval<T, values>), void(), 0)... };
}
template <typename T, typename Fn, CMT_ENABLE_IF(has_begin_end<T>::value)>
CMT_INTRIN void cforeach(T&& list, Fn&& fn)
{
for (const auto& v : list)
{
fn(v);
}
}
template <typename T, size_t N, typename Fn>
CMT_INTRIN void cforeach(const T (&array)[N], Fn&& fn)
{
for (size_t i = 0; i < N; i++)
{
fn(array[i]);
}
}
namespace details
{
template <typename... Ts, typename Fn, size_t... indices>
CMT_INTRIN void cforeach_tuple_impl(const std::tuple<Ts...>& tuple, Fn&& fn, csizes_t<indices...>)
{
swallow{ (fn(std::get<indices>(tuple)), void(), 0)... };
}
template <size_t index, typename... types>
CMT_INTRIN auto get_type_arg(ctypes_t<types...> type_list)
{
return ctype<type_of<details::get_nth_type<index, types...>>>;
}
template <typename T0, typename... types, typename Fn, size_t... indices>
CMT_INTRIN void cforeach_types_impl(ctypes_t<T0, types...> type_list, Fn&& fn, csizes_t<indices...>)
{
swallow{ (fn(get_type_arg<indices>(type_list)), void(), 0)... };
}
}
template <typename... Ts, typename Fn>
CMT_INTRIN void cforeach(ctypes_t<Ts...> types, Fn&& fn)
{
details::cforeach_types_impl(types, std::forward<Fn>(fn), csizeseq<sizeof...(Ts)>);
}
template <typename... Ts, typename Fn>
CMT_INTRIN void cforeach(const std::tuple<Ts...>& tuple, Fn&& fn)
{
details::cforeach_tuple_impl(tuple, std::forward<Fn>(fn), csizeseq<sizeof...(Ts)>);
}
template <typename A0, typename A1, typename Fn>
CMT_INTRIN void cforeach(A0&& a0, A1&& a1, Fn&& fn)
{
cforeach(std::forward<A0>(a0),
[&](auto v0) { cforeach(std::forward<A1>(a1), [&](auto v1) { fn(v0, v1); }); });
}
template <typename A0, typename A1, typename A2, typename Fn>
CMT_INTRIN void cforeach(A0&& a0, A1&& a1, A2&& a2, Fn&& fn)
{
cforeach(std::forward<A0>(a0), [&](auto v0) {
cforeach(std::forward<A1>(a1),
[&](auto v1) { cforeach(std::forward<A2>(a2), [&](auto v2) { fn(v0, v1, v2); }); });
});
}
template <typename TrueFn, typename FalseFn = fn_noop>
CMT_INTRIN decltype(auto) cif(cbool_t<true>, TrueFn&& truefn, FalseFn&& = FalseFn())
{
return truefn(cbool<true>);
}
template <typename TrueFn, typename FalseFn = fn_noop>
CMT_INTRIN decltype(auto) cif(cbool_t<false>, TrueFn&&, FalseFn&& falsefn = FalseFn())
{
return falsefn(cbool<false>);
}
template <typename T, T start, T stop, typename BodyFn>
CMT_INTRIN decltype(auto) cfor(cval_t<T, start>, cval_t<T, stop>, BodyFn&& bodyfn)
{
return cforeach(cvalrange<T, start, stop>, std::forward<BodyFn>(bodyfn));
}
template <typename T, T... vs, typename U, typename Function, typename Fallback = fn_noop>
void cswitch(cvals_t<T, vs...>, const U& value, Function&& function, Fallback&& fallback = Fallback())
{
bool result = false;
swallow{ (result = result || ((vs == value) ? (function(cval<T, vs>), void(), true) : false), void(),
0)... };
if (!result)
fallback();
}
template <typename T, typename Fn, typename DefFn = fn_noop, typename CmpFn = fn_is_equal>
CMT_INTRIN decltype(auto) cswitch(cvals_t<T>, identity<T>, Fn&&, DefFn&& deffn = DefFn(), CmpFn&& = CmpFn())
{
return deffn();
}
template <typename T, T v0, T... values, typename Fn, typename DefFn = fn_noop, typename CmpFn = fn_is_equal>
CMT_INTRIN decltype(auto) cswitch(cvals_t<T, v0, values...>, identity<T> value, Fn&& fn,
DefFn&& deffn = DefFn(), CmpFn&& cmpfn = CmpFn())
{
if (cmpfn(value, v0))
{
return fn(cval<T, v0>);
}
else
{
return cswitch(cvals_t<T, values...>(), value, std::forward<Fn>(fn), std::forward<DefFn>(deffn),
std::forward<CmpFn>(cmpfn));
}
}
namespace details
{
template <typename T, typename Fn1, typename Fn2, typename... Fns>
inline decltype(auto) cmatch_impl(T&& value, Fn1&& first, Fn2&& second, Fns&&... rest);
template <typename T, typename Fn, typename... Ts>
inline decltype(auto) cmatch_impl(T&& value, Fn&& last);
template <typename T, typename Fn, typename... Fns>
inline decltype(auto) cmatch_impl2(cbool_t<true>, T&& value, Fn&& fn, Fns&&...)
{
return fn(std::forward<T>(value));
}
template <typename T, typename Fn, typename... Fns>
inline decltype(auto) cmatch_impl2(cbool_t<false>, T&& value, Fn&&, Fns&&... rest)
{
return cmatch_impl(std::forward<T>(value), std::forward<Fns>(rest)...);
}
template <typename T, typename Fn1, typename Fn2, typename... Fns>
inline decltype(auto) cmatch_impl(T&& value, Fn1&& first, Fn2&& second, Fns&&... rest)
{
using first_arg = typename function_arguments<Fn1>::template nth<0>;
constexpr bool is_same = std::is_same<decay<T>, decay<first_arg>>::value;
return cmatch_impl2(cbool<is_same>, std::forward<T>(value), std::forward<Fn1>(first),
std::forward<Fn2>(second), std::forward<Fns>(rest)...);
}
template <typename T, typename Fn, typename... Ts>
inline decltype(auto) cmatch_impl(T&& value, Fn&& last)
{
return last(std::forward<T>(value));
}
}
template <typename T, typename Fn, typename... Args>
inline decltype(auto) cmatch(T&& value, Fn&& fn, Args... args)
{
return details::cmatch_impl(std::forward<T>(value), std::forward<Fn>(fn), std::forward<Args>(args)...);
}
namespace details
{
template <typename Result, typename... Args>
struct virtual_function
{
virtual Result operator()(Args... args) = 0;
virtual virtual_function* make_copy() const = 0;
CMT_INTRIN virtual ~virtual_function() = default;
};
template <typename Fn, typename Result, typename... Args>
struct virtual_function_impl : virtual_function<Result, Args...>
{
public:
CMT_INTRIN virtual_function_impl(const Fn& fn) : fn(fn) {}
CMT_INTRIN Result operator()(Args... args) override final { return fn(args...); }
CMT_INTRIN virtual_function<Result, Args...>* make_copy() const override final
{
return new virtual_function_impl{ fn };
}
CMT_INTRIN ~virtual_function_impl() {}
private:
Fn fn;
};
template <typename Fn>
struct func_filter
{
typedef Fn type;
};
template <typename Result, typename... Args>
struct func_filter<Result(Args...)>
{
typedef Result (*type)(Args...);
};
template <typename T>
constexpr CMT_INTRIN T return_val() noexcept
{
return {};
}
template <>
constexpr CMT_INTRIN void return_val<void>() noexcept
{
}
}
template <typename>
struct function;
/**
* @brief std::function-like lightweight function wrapper
* @code
* function<int( float )> f = []( float x ){ return static_cast<int>( x ); };
* CHECK( f( 3.4f ) == 3 )
* @encode
*/
template <typename Result, typename... Args>
struct function<Result(Args...)>
{
using this_t = function<Result(Args...)>;
function(function&& other) : fn(other.fn) { other.fn = nullptr; }
function& operator=(function&& other)
{
fn = other.fn;
other.fn = nullptr;
return *this;
}
CMT_INTRIN function() : fn(nullptr) {}
CMT_INTRIN function(std::nullptr_t) : fn(nullptr) {}
template <typename Func>
CMT_INTRIN function(const Func& x)
: fn(new details::virtual_function_impl<typename details::func_filter<Func>::type, Result, Args...>(
x))
{
}
function(const this_t& other) : fn(other.fn ? other.fn->make_copy() : nullptr) {}
CMT_INTRIN function& operator=(const this_t& other)
{
if ((&other != this) && (other.fn))
{
auto* temp = other.fn->make_copy();
delete fn;
fn = temp;
}
return *this;
}
CMT_INTRIN function& operator=(std::nullptr_t)
{
delete fn;
fn = nullptr;
return *this;
}
template <typename Fn>
CMT_INTRIN function& operator=(const Fn& x)
{
using FnImpl =
details::virtual_function_impl<typename details::func_filter<Fn>::type, Result, Args...>;
FnImpl* temp = new FnImpl(x);
delete fn;
fn = temp;
return *this;
}
CMT_INTRIN Result operator()(Args... args) const
{
if (fn)
return (*fn)(args...);
else
return details::return_val<Result>();
}
CMT_INTRIN explicit operator bool() const noexcept { return !!fn; }
CMT_INTRIN ~function() { delete fn; }
private:
details::virtual_function<Result, Args...>* fn;
};
template <typename Ret, typename... Args, typename T, typename Fn, typename DefFn = fn_noop>
CMT_INLINE function<Ret(Args...)> cdispatch(cvals_t<T>, identity<T>, Fn&&, DefFn&& deffn = DefFn())
{
return [=](Args... args) CMT_INLINE_MEMBER -> Ret { return deffn(std::forward<Args>(args)...); };
}
template <typename Ret, typename... Args, typename T, T v0, T... values, typename Fn,
typename DefFn = fn_noop>
inline function<Ret(Args...)> cdispatch(cvals_t<T, v0, values...>, identity<T> value, Fn&& fn,
DefFn&& deffn = DefFn())
{
if (value == v0)
{
return [=](Args... args)
CMT_INLINE_MEMBER -> Ret { return fn(cval<T, v0>, std::forward<Args>(args)...); };
}
else
{
return cdispatch<Ret, Args...>(cvals_t<T, values...>(), value, std::forward<Fn>(fn),
std::forward<DefFn>(deffn));
}
}
template <typename T, T... values>
inline size_t cfind(cvals_t<T, values...>, identity<T> value)
{
static const T temp[] = { values... };
return static_cast<size_t>(
std::distance(std::begin(temp), std::find(std::begin(temp), std::end(temp), value)));
}
template <typename Fn, typename... Args>
CMT_NOINLINE static result_of<Fn(Args...)> noinline(Fn&& fn, Args&&... args)
{
return fn(std::forward<Args>(args)...);
}
template <typename Fn>
struct fn_noinline
{
template <typename... Args>
CMT_INTRIN result_of<Fn(Args...)> operator()(Args&&... args) const
{
return noinline(Fn{}, std::forward<Args>(args)...);
}
};
template <typename... Args, typename Fn, typename Ret = decltype(std::declval<Fn>()(std::declval<Args>()...)),
typename NonMemFn = Ret (*)(Fn*, Args...)>
CMT_INTRIN NonMemFn make_nonmember(const Fn&)
{
return [](Fn* fn, Args... args) -> Ret { return fn->operator()(std::forward<Args>(args)...); };
}
template <typename T>
struct array_ref
{
public:
using value_type = T;
using pointer = value_type*;
using const_pointer = const value_type*;
using reference = value_type&;
using const_reference = const value_type&;
using iterator = pointer;
using const_iterator = const_pointer;
using reverse_iterator = std::reverse_iterator<pointer>;
using const_reverse_iterator = std::reverse_iterator<const_iterator>;
using size_type = std::size_t;
using difference_type = std::ptrdiff_t;
constexpr array_ref() noexcept : m_data(nullptr), m_size(0) {}
constexpr array_ref(const array_ref&) noexcept = default;
constexpr array_ref(array_ref&&) noexcept = default;
constexpr array_ref& operator=(const array_ref&) noexcept = default;
constexpr array_ref& operator=(array_ref&&) noexcept = default;
template <size_t N>
constexpr array_ref(value_type (&arr)[N]) noexcept : m_data(arr), m_size(N)
{
}
template <size_t N>
constexpr array_ref(const std::array<T, N>& arr) noexcept : m_data(arr.data()), m_size(N)
{
}
template <size_t N>
constexpr array_ref(std::array<T, N>& arr) noexcept : m_data(arr.data()), m_size(N)
{
}
template <typename... Ts>
constexpr array_ref(const std::vector<T, Ts...>& vec) noexcept : m_data(vec.data()), m_size(vec.size())
{
}
template <typename... Ts, CMT_ENABLE_IF(sizeof...(Ts), is_const<T>::value)>
constexpr array_ref(const std::vector<remove_const<T>, Ts...>& vec) noexcept : m_data(vec.data()),
m_size(vec.size())
{
}
template <typename... Ts>
constexpr array_ref(std::vector<T, Ts...>& vec) noexcept : m_data(vec.data()), m_size(vec.size())
{
}
template <typename InputIter>
constexpr array_ref(InputIter first, InputIter last) noexcept : m_data(std::addressof(*first)),
m_size(std::distance(first, last))
{
}
constexpr array_ref(T* data, size_type size) noexcept : m_data(data), m_size(size) {}
constexpr reference front() const noexcept { return m_data[0]; }
constexpr reference back() const noexcept { return m_data[m_size - 1]; }
constexpr iterator begin() const noexcept { return m_data; }
constexpr iterator end() const noexcept { return m_data + m_size; }
constexpr const_iterator cbegin() const noexcept { return m_data; }
constexpr const_iterator cend() const noexcept { return m_data + m_size; }
constexpr pointer data() const noexcept { return m_data; }
constexpr std::size_t size() const noexcept { return m_size; }
constexpr bool empty() const noexcept { return !m_size; }
constexpr reference operator[](std::size_t index) const { return m_data[index]; }
private:
pointer m_data;
size_type m_size;
};
template <typename T>
constexpr inline T choose_const()
{
static_assert(sizeof(T) != 0, "T not found in the list of template arguments");
return T();
}
/**
* Selects constant of the specific type
* @code
* CHECK( choose_const<f32>( 32.0f, 64.0 ) == 32.0f );
* CHECK( choose_const<f64>( 32.0f, 64.0 ) == 64.0 );
* @endcode
*/
template <typename T, typename C1, typename... Cs>
constexpr inline T choose_const(C1 c1, Cs... constants)
{
return std::is_same<T, C1>::value ? static_cast<T>(c1) : choose_const<T>(constants...);
}
template <typename T, std::size_t size>
inline array_ref<T> make_array_ref(T (&data)[size])
{
return array_ref<T>(data);
}
template <typename T>
inline array_ref<T> make_array_ref(T* data, std::size_t size)
{
return array_ref<T>(data, data + size);
}
template <typename Container, CMT_ENABLE_IF(has_data_size<Container>::value),
typename T = remove_pointer<decltype(std::declval<Container>().data())>>
inline array_ref<T> make_array_ref(Container& cont)
{
return array_ref<T>(cont.data(), cont.size());
}
template <typename Container, CMT_ENABLE_IF(has_data_size<Container>::value),
typename T = remove_pointer<decltype(std::declval<Container>().data())>>
inline array_ref<const T> make_array_ref(const Container& cont)
{
return array_ref<const T>(cont.data(), cont.size());
}
template <typename T>
inline array_ref<T> make_array_ref(std::vector<T>& cont)
{
return array_ref<T>(cont.data(), cont.size());
}
template <typename T>
inline array_ref<const T> make_array_ref(const std::vector<T>& cont)
{
return array_ref<const T>(cont.data(), cont.size());
}
template <typename Type, typename ErrEnum, ErrEnum OkValue = static_cast<ErrEnum>(0)>
struct result
{
using value_type = Type;
using reference = value_type&;
using const_reference = const value_type&;
using pointer = value_type*;
using const_pointer = const value_type*;
using error_type = ErrEnum;
constexpr static error_type ok_value = OkValue;
constexpr result(const result&) = default;
constexpr result(result&&) noexcept = default;
constexpr result(ErrEnum error) noexcept : m_error(error) {}
template <typename ValueInit, CMT_ENABLE_IF(std::is_constructible<value_type, ValueInit>::value)>
constexpr result(ValueInit&& value) noexcept : m_value(std::forward<ValueInit>(value)), m_error(OkValue)
{
}
constexpr result(const Type& value) noexcept : m_value(value), m_error(OkValue) {}
constexpr result(Type&& value) noexcept : m_value(std::move(value)), m_error(OkValue) {}
constexpr explicit operator bool() const { return m_error == OkValue; }
constexpr const_reference operator*() const { return m_value; }
constexpr reference operator*() { return m_value; }
constexpr const_pointer operator->() const { return &m_value; }
constexpr pointer operator->() { return &m_value; }
constexpr const_reference value() const { return m_value; }
constexpr reference value() { return m_value; }
constexpr ErrEnum error() const { return m_error; }
constexpr bool ok() const { return m_error == OkValue; }
private:
Type m_value;
ErrEnum m_error;
};
template <typename Tfrom>
struct autocast_impl
{
const Tfrom value;
template <typename T>
CMT_INTRIN constexpr operator T() const noexcept
{
return static_cast<T>(value);
}
};
template <typename Tfrom>
CMT_INTRIN constexpr autocast_impl<Tfrom> autocast(const Tfrom& value) noexcept
{
return { value };
}
inline void stop_constexpr() {}
namespace details
{
template <typename T, typename = void>
struct signed_type_impl
{
using type = T;
};
template <typename T>
struct signed_type_impl<T, void_t<enable_if<std::is_unsigned<T>::value>>>
{
using type = findinttype<std::numeric_limits<T>::min(), std::numeric_limits<T>::max()>;
};
}
template <typename T>
using signed_type = typename details::signed_type_impl<T>::type;
template <typename T>
struct range
{
using value_type = T;
using reference = T&;
using const_reference = const T&;
using pointer = T*;
using const_pointer = const T*;
using diff_type = decltype(std::declval<T>() - std::declval<T>());
constexpr range(value_type begin, value_type end, diff_type step) noexcept : value_begin(begin),
value_end(end),
step(step)
{
}
struct iterator
{
value_type value;
diff_type step;
const_reference operator*() const { return value; }
const_pointer operator->() const { return &value; }
iterator& operator++()
{
value += step;
return *this;
}
iterator operator++(int)
{
iterator copy = *this;
++(*this);
return copy;
}
bool operator!=(const iterator& other) const
{
return step > 0 ? value < other.value : value > other.value;
}
};
value_type value_begin;
value_type value_end;
diff_type step;
iterator begin() const { return iterator{ value_begin, step }; }
iterator end() const { return iterator{ value_end, step }; }
};
template <typename T>
range<T> make_range(T begin, T end)
{
return range<T>(begin, end, end > begin ? 1 : -1);
}
template <typename T, typename diff_type = decltype(std::declval<T>() - std::declval<T>())>
range<T> make_range(T begin, T end, diff_type step)
{
return range<T>(begin, end, step);
}
template <typename T>
struct named_arg
{
T value;
const char* name;
};
struct named
{
constexpr named(const char* name) noexcept : name(name) {}
template <typename T>
CMT_INTRIN constexpr named_arg<T> operator=(T&& value)
{
return named_arg<T>{ std::forward<T>(value), name };
}
const char* name;
};
inline named operator""_arg(const char* name, size_t) { return name; }
template <size_t N>
struct cstring
{
using value_type = char;
using size_type = size_t;
constexpr const value_type* c_str() const noexcept { return value; }
constexpr const value_type* data() const noexcept { return value; }
const value_type value[N];
constexpr size_type length() const noexcept { return N - 1; }
constexpr size_type size() const noexcept { return N; }
constexpr friend bool operator==(const cstring& left, const cstring& right) noexcept
{
for (size_t i = 0; i < 1; i++)
if (left.value[i] != right.value[i])
return false;
return true;
}
constexpr friend bool operator!=(const cstring& left, const cstring& right) noexcept
{
return !(left == right);
}
template <size_t NN>
constexpr bool operator==(const cstring<NN>& other) const noexcept
{
return false;
}
template <size_t NN>
constexpr bool operator!=(const cstring<NN>& other) const noexcept
{
return true;
}
constexpr char operator[](size_t index) const noexcept { return value[index]; }
};
namespace details
{
template <size_t N, size_t... indices>
CMT_INLINE constexpr cstring<N> make_cstring_impl(const char (&str)[N], csizes_t<indices...>)
{
return { { str[indices]..., 0 } };
}
template <size_t N1, size_t N2, size_t... indices>
CMT_INLINE constexpr cstring<N1 - 1 + N2 - 1 + 1> concat_str_impl(const cstring<N1>& str1,
const cstring<N2>& str2,
csizes_t<indices...>)
{
constexpr size_t L1 = N1 - 1;
return { { (indices < L1 ? str1[indices] : str2[indices - L1])..., 0 } };
}
template <size_t N1, size_t N2, typename... Args>
CMT_INLINE constexpr cstring<N1 - 1 + N2 - 1 + 1> concat_str_impl(const cstring<N1>& str1,
const cstring<N2>& str2)
{
return concat_str_impl(str1, str2, csizeseq<N1 - 1 + N2 - 1>);
}
template <size_t N1, size_t Nfrom, size_t Nto, size_t... indices>
CMT_INTRIN cstring<N1 - Nfrom + Nto> str_replace_impl(size_t pos, const cstring<N1>& str,
const cstring<Nfrom>&, const cstring<Nto>& to,
csizes_t<indices...>)
{
if (pos == size_t(-1))
stop_constexpr();
return { { (indices < pos ? str[indices] : (indices < pos + Nto - 1) ? to[indices - pos]
: str[indices - Nto + Nfrom])...,
0 } };
}
}
CMT_INTRIN constexpr cstring<1> concat_cstring() { return { { 0 } }; }
template <size_t N1>
CMT_INTRIN constexpr cstring<N1> concat_cstring(const cstring<N1>& str1)
{
return str1;
}
template <size_t N1, size_t N2, typename... Args>
CMT_INTRIN constexpr auto concat_cstring(const cstring<N1>& str1, const cstring<N2>& str2,
const Args&... args)
{
return details::concat_str_impl(str1, concat_cstring(str2, args...));
}
template <size_t N>
CMT_INTRIN constexpr cstring<N> make_cstring(const char (&str)[N])
{
return details::make_cstring_impl(str, csizeseq<N - 1>);
}
template <char... chars>
CMT_INTRIN constexpr cstring<sizeof...(chars) + 1> make_cstring(cchars_t<chars...>)
{
return { { chars..., 0 } };
}
template <size_t N1, size_t Nneedle>
CMT_INTRIN size_t str_find(const cstring<N1>& str, const cstring<Nneedle>& needle)
{
size_t count = 0;
for (size_t i = 0; i < N1; i++)
{
if (str[i] == needle[count])
count++;
else
count = 0;
if (count == Nneedle - 1)
return i + 1 - (Nneedle - 1);
}
return size_t(-1);
}
template <size_t N1, size_t Nfrom, size_t Nto>
CMT_INTRIN cstring<N1 - Nfrom + Nto> str_replace(const cstring<N1>& str, const cstring<Nfrom>& from,
const cstring<Nto>& to)
{
return details::str_replace_impl(str_find(str, from), str, from, to, csizeseq<N1 - Nfrom + Nto - 1>);
}
using pconstvoid = const void*;
struct type_id_t
{
constexpr type_id_t(const void* id) noexcept : id(id) {}
constexpr bool operator==(type_id_t other) const { return id == other.id; }
constexpr bool operator!=(type_id_t other) const { return !(id == other.id); }
const void* const id;
};
namespace details
{
constexpr inline size_t strlen(const char* str) { return *str ? 1 + cometa::details::strlen(str + 1) : 0; }
template <typename T>
constexpr inline type_id_t typeident_impl() noexcept
{
return type_id_t(pconstvoid(&typeident_impl<T>));
}
#ifdef CMT_COMPILER_CLANG
constexpr size_t typename_prefix = sizeof("auto cometa::ctype_name() [T = ") - 1;
constexpr size_t typename_postfix = sizeof("]") - 1;
#else
constexpr size_t typename_prefix = sizeof("constexpr auto cometa::ctype_name() [with T = ") - 1;
constexpr size_t typename_postfix = sizeof("]") - 1;
#endif
template <size_t... indices, size_t Nout = 1 + sizeof...(indices)>
constexpr cstring<Nout> gettypename_impl(const char* str, csizes_t<indices...>) noexcept
{
return cstring<Nout>{ (str[indices])..., 0 };
}
}
template <typename T>
constexpr auto ctype_name() noexcept
{
constexpr size_t length =
sizeof(CMT_FUNC_SIGNATURE) - 1 - details::typename_prefix - details::typename_postfix;
return details::gettypename_impl(CMT_FUNC_SIGNATURE + details::typename_prefix, csizeseq<length>);
}
/**
* @brief Gets the fully qualified name of the type, including namespace and
* template parameters (if any)
* @tparam T type
* @return name of the type
*/
template <typename T>
inline const char* type_name() noexcept
{
static const auto name = ctype_name<T>();
return name.c_str();
}
/**
* @brief Gets the fully qualified name of the type, including namespace and
* template parameters (if any)
* @param x value of specific type
* @return name of the type
*/
template <typename T>
inline const char* type_name(T x) noexcept
{
(void)x;
return type_name<T>();
}
/**
* @brief Gets unique value associated with the type
* @tparam T type
* @return value of type that supports operator== and operator!=
*/
template <typename T>
constexpr inline type_id_t ctypeid()
{
return details::typeident_impl<T>();
}
/**
* @brief Gets unique value associated with the type
* @param x value of specific type
* @return value of type that supports operator== and operator!=
*/
template <typename T>
constexpr inline type_id_t ctypeid(T x)
{
(void)x;
return details::typeident_impl<T>();
}
}
#pragma gcc diagnostic pop