Meta.h

Go to the documentation of this file.

// Honeycomb, Copyright (C) 2015 NewGamePlus Inc.  Distributed under the Boost Software License v1.0.
#pragma once

#include "Honey/Core/Preprocessor.h"

namespace honey
{



namespace mt
{

#define mt_unused(Param)                                        (void)Param;
#define mt_unpackEval(...)                                      mt::pass(((__VA_ARGS__), 0)...)

template<class T> struct identity                               { typedef T type; };
template<class... Args> void pass(Args...) {}
template<class T, T val> using Value                            = std::integral_constant<T, val>;
template<class...> struct True                                  : std::true_type {};
template<int64...> struct True_int                              : std::true_type {};
template<class T> using isTrue                                  = Value<bool, std::is_same<T, std::true_type>::value>;
struct Void {};
template<int> struct tag                                        { tag() = default; tag(int) {} };

template<class T> using addRef                                  = std::add_lvalue_reference<T>;
template<class T> using removeRef                               = std::remove_reference<T>;
template<class T> using addPtr                                  = std::add_pointer<T>;
template<class T> using removePtr                               = std::remove_pointer<T>;
template<class T> using addConstRef                             = addRef<typename std::add_const<T>::type>;

template<class T> using isLref                                  = Value<bool, std::is_lvalue_reference<T>::value>;
template<class T> using isRref                                  = Value<bool, std::is_rvalue_reference<T>::value>;
template<class T> using isRef                                   = Value<bool, std::is_reference<T>::value>;
template<class T> using isPtr                                   = Value<bool, std::is_pointer<T>::value>;
    
template<bool b, class T = void> using disable_if               = std::enable_if<!b, T>;

template<bool b, int64 t, int64 f> struct conditional_int       : Value<int64, f> {};
template<int64 t, int64 f> struct conditional_int<true, t, f>   : Value<int64, t> {};

template<class Base, class Derived> struct is_base_of           : std::is_base_of<typename removeRef<Base>::type, typename removeRef<Derived>::type> {};

template<class T, template<class...> class Template>
struct isSpecializationOf                                       : std::false_type {};
template<template<class...> class Template, class... Param>
struct isSpecializationOf<Template<Param...>, Template>         : std::true_type {};
    
template<class T> using isTuple                                 = isSpecializationOf<typename std::decay<T>::type, tuple>;

template<class Func, class... Args>
class isCallable
{
    template<class F> static auto                               test(void*) -> decltype(declval<F>()(declval<Args>()...), std::true_type());
    template<class F> static std::false_type                    test(...);
public:
    static const bool value = isTrue<decltype(test<Func>(nullptr))>::value;
};

namespace priv
{
    template<int cur, int end, class... Ts> struct typeAt;
    template<int cur, int end, class T, class... Ts> struct typeAt<cur, end, T, Ts...>      : typeAt<cur+1, end, Ts...> {};
    template<int cur, class T, class... Ts> struct typeAt<cur, cur, T, Ts...>               { typedef T type; };
    template<int cur, int end> struct typeAt<cur, end> {};
    
    template<int cur, class Match, class... Ts> struct typeIndex;
    template<int cur, class Match, class T, class... Ts> struct typeIndex<cur, Match, T, Ts...> : typeIndex<cur+1, Match, Ts...> {};
    template<int cur, class T, class... Ts> struct typeIndex<cur, T, T, Ts...>              : Value<int, cur> {};
    template<int cur, class Match> struct typeIndex<cur, Match>                             : Value<int, -1> {};
}
template<int I, class... Ts> using typeAt                       = typename priv::typeAt<0, I, Ts...>::type;
template<class Match, class... Ts> using typeIndex              = priv::typeIndex<0, Match, Ts...>;

template<szt... Ints> using idxseq                              = std::index_sequence<Ints...>;
template<szt N> using make_idxseq                               = std::make_index_sequence<N>;

namespace priv
{
    template<class Func, class Tuple, szt... Seq>
    auto applyTuple(Func&& f, Tuple&& t, idxseq<Seq...>)        { return f(get<Seq>(forward<Tuple>(t))...); }
}
template<class Func, class Tuple>
auto applyTuple(Func&& f, Tuple&& t)                            { return priv::applyTuple(forward<Func>(f), forward<Tuple>(t), make_idxseq<tuple_size<typename removeRef<Tuple>::type>::value>()); }

template<class Array> using arraySize                           = Value<szt, sizeof(Array) / sizeof(typename Array::value_type)>;

template<class T, class... Ts>
auto make_array(T&& t, Ts&&... ts) -> array<T, sizeof...(Ts)+1> { return {forward<T>(t), forward<Ts>(ts)...}; }

inline void exec() {} //dummy to catch empty parameter pack
template<class Func, class... Funcs>
void exec(Func&& f, Funcs&&... fs)                              { f(); exec(forward<Funcs>(fs)...); }
    
template<int64 begin, int64 end, int64 step = 1, class Func, class... Args, typename std::enable_if<begin == end, int>::type=0>
void for_(Func&& f, Args&&... args)                             {}
template<int64 begin, int64 end, int64 step = 1, class Func, class... Args, typename std::enable_if<begin != end, int>::type=0>
void for_(Func&& f, Args&&... args)                             { f(begin, forward<Args>(args)...); for_<begin+step, end, step>(forward<Func>(f), forward<Args>(args)...); }
    

#define mt_hasMember(MemberName)                                mt_hasMember2(MemberName, MemberName)
#define mt_hasMember2(MemberName, TestName)                                                                                     \
    template<class Class, class MemberType>                                                                                     \
    class mt_hasMember_##TestName                                                                                               \
    {                                                                                                                           \
        template<class T, T>                        struct matchType;                                                           \
        template<class T> static auto               memberMatch(void*) -> decltype(declval<matchType<MemberType, &T::MemberName>>(), std::true_type()); \
        template<class T> static std::false_type    memberMatch(...);                                                           \
    public:                                                                                                                     \
        static const bool value = mt::isTrue<decltype(memberMatch<Class>(nullptr))>::value;                                     \
        typedef typename std::conditional<value, MemberType, mt::Void>::type type;                                              \
    };



#define mt_hasType(TypeName)                                    mt_hasType2(TypeName, TypeName)
#define mt_hasType2(TypeName, TestName)                                                                                         \
    template<class Class>                                                                                                       \
    class mt_hasType_##TestName                                                                                                 \
    {                                                                                                                           \
        template<class T> static auto               test(void*) -> decltype(declval<typename T::TypeName>(), std::true_type()); \
        template<class T> static std::false_type    test(...);                                                                  \
                                                                                                                                \
        template<bool Res, class Enable = void>                                                                                 \
        struct testType                                             { typedef mt::Void type; };                                 \
        template<bool Res>                                                                                                      \
        struct testType<Res, typename std::enable_if<Res>::type>    { typedef typename Class::TypeName type; };                 \
    public:                                                                                                                     \
        static const bool value = mt::isTrue<decltype(test<Class>(nullptr))>::value;                                            \
        typedef typename testType<value>::type type;                                                                            \
    };


namespace priv
{
    mt_hasType(iterator_category)
    template<class T> struct isIterator                         : Value<bool, mt_hasType_iterator_category<T>::value || isPtr<T>::value> {};
}
template<class T> using isIterator                              = priv::isIterator<typename removeRef<T>::type>;


template<class T> struct funcTraits;


struct FuncptrBase {};

template<class Sig> struct Funcptr;

template<class R, class... Args>
struct Funcptr<R (Args...)>
{
    typedef R (FuncptrBase::*Func)(Args...);
    
    Funcptr()                                                   : base(nullptr), func(nullptr) {}
    Funcptr(nullptr_t)                                          : Funcptr() {}
    template<class F> Funcptr(F&& f)                            { operator=(forward<F>(f)); }
    template<class F> Funcptr& operator=(F&& f)                 { base = &f; func = static_cast<Func>(&removeRef<F>::type::operator()); return *this; }
    Funcptr& operator=(nullptr_t)                               { base = nullptr; func = nullptr; return *this; }
    template<class... Args_>
    R operator()(Args_&&... args) const                         { return (base->*func)(forward<Args_>(args)...); }
    bool operator==(const Funcptr& rhs) const                   { return base == rhs.base && func == rhs.func; }
    bool operator!=(const Funcptr& rhs) const                   { return !operator==(rhs); }
    explicit operator bool() const                              { return base && func; }
    
    FuncptrBase* base;
    Func func;
};

template<class... Args>
struct Funcptr<void (Args...)>
{
    typedef void (FuncptrBase::*Func)(Args...);
    
    Funcptr()                                                   : base(nullptr), func(nullptr) {}
    Funcptr(nullptr_t)                                          : Funcptr() {}
    template<class F> Funcptr(F&& f)                            { operator=(forward<F>(f)); }
    template<class F> Funcptr& operator=(F&& f)                 { base = &f; func = static_cast<Func>(&removeRef<F>::type::operator()); return *this; }
    Funcptr& operator=(nullptr_t)                               { base = nullptr; func = nullptr; return *this; }
    template<class... Args_>
    void operator()(Args_&&... args) const                      { (base->*func)(forward<Args_>(args)...); }
    bool operator==(const Funcptr& rhs) const                   { return base == rhs.base && func == rhs.func; }
    bool operator!=(const Funcptr& rhs) const                   { return !operator==(rhs); }
    explicit operator bool() const                              { return base && func; }
    
    FuncptrBase* base;
    Func func;
};

template<class F, class Sig = typename funcTraits<typename removeRef<F>::type>::Sig>
Funcptr<Sig> FuncptrCreate(F&& f)                               { return Funcptr<Sig>(forward<F>(f)); }


#define mt_global(Class, Func, Ctor)                            inline UNBRACKET(Class)& Func()  { static UNBRACKET(Class) obj Ctor; return obj; }

struct NoCopy
{
    NoCopy(const NoCopy&) = delete;
    NoCopy& operator=(const NoCopy&) = delete;
protected:
    NoCopy() = default;
};


template<int64... vals> struct min;
template<int64 val, int64... vals> struct min<val, vals...>     : Value<int64, (val < min<vals...>::value ? val : min<vals...>::value)> {};
template<int64 val> struct min<val>                             : Value<int64, val> {};
    

template<int64... vals> struct max;
template<int64 val, int64... vals> struct max<val, vals...>     : Value<int64, (val > max<vals...>::value ? val : max<vals...>::value)> {};
template<int64 val> struct max<val>                             : Value<int64, val> {};

template<int64 val> using abs                                   = Value<int64, (val < 0) ? -val : val>;
template<int64 val> using sign                                  = Value<int64, (val < 0) ? -1 : 1>;

template<uint64 x> struct log2Floor                             : Value<int, log2Floor<x/2>::value+1> {};
template<> struct log2Floor<0>                                  : Value<int, -1> {};

template<int64 a, int64 b> struct gcd                           : gcd<b, a % b> {};
template<int64 a> struct gcd<a, 0>                              : Value<int64, abs<a>::value> {};
template<int64 b> struct gcd<0, b>                              : Value<int64, abs<b>::value> {};

namespace priv
{
    template<uint64 N> struct byteCount                         : Value<int, ((max<log2Floor<N>::value, 1>::value + 7) >> 3)> {};

    template<uint64 N> struct byteType                          : identity<uint64> {};
    template<> struct byteType<4>                               : identity<uint32> {};
    template<> struct byteType<3>                               : identity<uint32> {};
    template<> struct byteType<2>                               : identity<uint16> {};
    template<> struct byteType<1>                               : identity<uint8> {};
}
template<uint64 N> struct uintByValue                           : priv::byteType<priv::byteCount<N>::value> {};
template<int N> struct uintBySize                               : priv::byteType<N> {};

//====================================================
// funcTraits
//====================================================
namespace priv
{
    template<class T> struct functorTraits {};
}
template<class T> struct funcTraits                             : priv::functorTraits<decltype(&T::operator())> {};

#define TRAITS(Ptr)                                                                         \
    template<class R, class... Args>                                                        \
    struct funcTraits<R Ptr (Args...)>                                                      \
    {                                                                                       \
        typedef R Sig(Args...);                                                             \
        typedef void Base;                                                                  \
        typedef R Return;                                                                   \
        static const szt arity = sizeof...(Args);                                           \
        template<szt I> using param = typeAt<I, Args...>;                                   \
    };                                                                                      \

#define M_TRAITS(Const)                                                                     \
    template<class R, class Base_, class... Args>                                           \
    struct funcTraits<R (Base_::*) (Args...) Const>                                         \
    {                                                                                       \
        typedef R (Base_::*Sig) (Args...) Const;                                            \
        typedef Base_ Base;                                                                 \
        typedef R Return;                                                                   \
        static const szt arity = sizeof...(Args)+1;                                         \
    private:                                                                                \
        template<szt I, szt _=0> struct param_  { typedef typeAt<I-1, Args...> type; };     \
        template<szt _> struct param_<0, _>     { typedef Const Base* type; };              \
    public:                                                                                 \
        template<szt I> using param = typename param_<I>::type;                             \
    };                                                                                      \
                                                                                            \
    namespace priv                                                                          \
    {                                                                                       \
    template<class R, class Base_, class... Args>                                           \
    struct functorTraits<R (Base_::*) (Args...) Const>                                      \
    {                                                                                       \
        typedef R Sig(Args...);                                                             \
        typedef void Base;                                                                  \
        typedef R Return;                                                                   \
        static const szt arity = sizeof...(Args);                                           \
        template<szt I> using param = mt::typeAt<I, Args...>;                               \
    };                                                                                      \
    }                                                                                       \

TRAITS()
TRAITS(&)
TRAITS(*)
M_TRAITS()
M_TRAITS(const)
#undef TRAITS
#undef M_TRAITS

//====================================================

} }