meta.h

Go to the documentation of this file.

// Evo C++ Library
/* Copyright 2019 Justin Crowell
Distributed under the BSD 2-Clause License -- see included file LICENSE.txt for details.
*/

#pragma once
#ifndef INCL_evo_meta_h
#define INCL_evo_meta_h

#include "impl/sys.h"

namespace evo {


template<bool b> struct StaticAssertTrue;
template<>       struct StaticAssertTrue<true> { };
template<int N>  struct StaticAssertTestSize { };
#define EVO_STATIC_JOIN(A,B) IMPL_EVO_STATIC_JOIN1(A,B)

#define IMPL_EVO_STATIC_JOIN1(A,B) IMPL_EVO_STATIC_JOIN2(A,B)
#define IMPL_EVO_STATIC_JOIN2(A,B) A##B

#if defined(EVO_CPP11)

    #define STATIC_ASSERT(EXP,TOKEN) static_assert(EXP,#TOKEN)
#else
    #define STATIC_ASSERT(EXP,TOKEN) typedef ::evo::StaticAssertTestSize< sizeof(::evo::StaticAssertTrue<(bool)(EXP)>) > \
        EVO_STATIC_JOIN(TOKEN, __LINE__) EVO_ATTRIB_UNUSED
#endif

#if defined(EVO_CPP11)

    #define STATIC_ASSERT_FUNC_UNUSED =delete;

    #define STATIC_ASSERT_FUNC_UNUSED_RET(RET) =delete;
#elif defined(__clang__)
    #define STATIC_ASSERT_FUNC_UNUSED ;
    #define STATIC_ASSERT_FUNC_UNUSED_RET(RET) ;
#else
    #define STATIC_ASSERT_FUNC_UNUSED          { ::evo::StaticAssertTrue<false> EVO_STATIC_JOIN(_ASSERT_FUNC_UNUSED_, __LINE__); }
    #define STATIC_ASSERT_FUNC_UNUSED_RET(RET) { ::evo::StaticAssertTrue<false> EVO_STATIC_JOIN(_ASSERT_FUNC_UNUSED_, __LINE__); return RET; }
#endif


template<bool val> struct StaticBool {
    typedef typename evo::StaticBool<val> Type;    
    static const bool value = val;                
};

typedef StaticBool<false> StaticBoolF;

typedef StaticBool<true> StaticBoolT;

template<bool b, class T, class F> struct StaticIf {  typedef T Type; };
template<class T, class F> struct StaticIf<false,T,F> { typedef F Type; };
template<class T, class F> struct StaticIf<true,T,F> { typedef T Type; };

template<class T1, class T2> struct IsSame : public StaticBoolF { };
template<class T> struct IsSame<T,T> : public StaticBoolT { };
template<class T> struct IsPointer : public StaticBoolF { };
template<class T> struct IsPointer<T*> : public StaticBoolT { };
template<class T> struct IsArray : public StaticBoolF { };
template<class T> struct IsArray<T[]> : public StaticBoolT { };
template<class T, ulong N> struct IsArray<T[N]> : public StaticBoolT { };
template<class T> struct IsReference : public StaticBoolF { };
template<class T> struct IsReference<T&> : public StaticBoolT { };
template<class T> struct IsConst : public StaticBoolF { };
template<class T> struct IsConst<const T> : public StaticBoolT { };
template<class T> struct IsBool : public StaticBoolF { };
template<> struct IsBool<bool> : public StaticBoolT { };
template<class T> struct IsInt : public StaticBoolF { };
template<> struct IsInt<char>                : public StaticBoolT { };
template<> struct IsInt<signed char>         : public StaticBoolT { };
template<> struct IsInt<signed short>        : public StaticBoolT { };
template<> struct IsInt<signed int>          : public StaticBoolT { };
template<> struct IsInt<signed long>         : public StaticBoolT { };
template<> struct IsInt<signed long long>    : public StaticBoolT { };
template<> struct IsInt<unsigned char>       : public StaticBoolT { };
template<> struct IsInt<unsigned short>      : public StaticBoolT { };
template<> struct IsInt<unsigned int>        : public StaticBoolT { };
template<> struct IsInt<unsigned long>       : public StaticBoolT { };
template<> struct IsInt<unsigned long long>  : public StaticBoolT { };
template<class T> struct IsFloat : public StaticBoolF { };
template<> struct IsFloat<float>       : public StaticBoolT { };
template<> struct IsFloat<double>      : public StaticBoolT { };
template<> struct IsFloat<long double> : public StaticBoolT { };
template<class T> struct IsSigned : public StaticBoolT { };
template<> struct IsSigned<unsigned char>      : public StaticBoolF { };
template<> struct IsSigned<unsigned short>     : public StaticBoolF { };
template<> struct IsSigned<unsigned int>       : public StaticBoolF { };
template<> struct IsSigned<unsigned long>      : public StaticBoolF { };
template<> struct IsSigned<unsigned long long> : public StaticBoolF { };
template<class T, class U>
class IsConvertible {
private:
    typedef char SmallType;
    class LargeType { char dummy[2]; };
    static SmallType check(const U&);
    static LargeType check(...);
    static T make();

public:
    static const bool value = (sizeof(check(make())) == sizeof(SmallType)); 
};


template<class T> struct AddConst {  typedef const T Type; };
template<class T> struct AddConst<const T> { typedef T Type; };
template<class T> struct RemoveConst {  typedef T Type; };
template<class T> struct RemoveConst<const T> { typedef T Type; };
template<class T> struct RemoveVolatile {  typedef T Type; };
template<class T> struct RemoveVolatile<volatile T> { typedef T Type; };
template<class T> struct RemoveConstVol {  typedef T Type; };
template<class T> struct RemoveConstVol<const T>    { typedef typename RemoveConstVol<T>::Type Type; };
template<class T> struct RemoveConstVol<volatile T> { typedef typename RemoveConstVol<T>::Type Type; };
template<class T> struct RemoveExtents {  typedef T Type; };
template<class T> struct RemoveExtents<T*>            { typedef typename RemoveExtents<T>::Type Type; };
template<class T> struct RemoveExtents<T[]>           { typedef typename RemoveExtents<T>::Type Type; };
template<class T, ulong N> struct RemoveExtents<T[N]> { typedef typename RemoveExtents<T>::Type Type; };
template<class T> struct RemoveExtentsConstVol {  typedef typename RemoveConstVol<typename RemoveExtents<T>::Type>::Type Type; };


template<class T> struct ToSigned {  typedef T Type; };
template<> struct ToSigned<unsigned char>      { typedef char Type; };
template<> struct ToSigned<unsigned short>     { typedef short Type; };
template<> struct ToSigned<unsigned int>       { typedef int   Type; };
template<> struct ToSigned<unsigned long>      { typedef long  Type; };
template<> struct ToSigned<unsigned long long> { typedef long  Type; };
template<class T> struct ToUnsigned {  typedef T Type; };
template<> struct ToUnsigned<signed char> { typedef unsigned char  Type; };
template<> struct ToUnsigned<char>        { typedef unsigned char  Type; };
template<> struct ToUnsigned<short>       { typedef unsigned short Type; };
template<> struct ToUnsigned<int>         { typedef unsigned int   Type; };
template<> struct ToUnsigned<long>        { typedef unsigned long  Type; };
template<> struct ToUnsigned<long long>   { typedef unsigned long long Type; };

#define EVO_TRAIT_CREATE(Name) template<class T> struct Name : StaticBoolF { };

#define EVO_TRAIT_SET(Name,Type) template<> struct Name< Type > : public StaticBoolT { };

#define EVO_TRAIT_NSET(Namespace,Name,Type) namespace Namespace { template<> struct Name< Type > : public StaticBoolT { }; }


EVO_TRAIT_CREATE(EvoContainer)


#define EVO_CONTAINER(Type) EVO_TRAIT_NSET(evo,EvoContainer,Type)

#define EVO_CONTAINER_TYPE typedef void EvoContainerType


// Applies (calls) f(type) for each builtin type
#define EVO_APPLY_BUILTINS(f) \
    f(bool); \
    f(char); \
    f(signed char); \
    f(unsigned char); \
    f(short); \
    f(unsigned short); \
    f(int); \
    f(unsigned int); \
    f(long); \
    f(unsigned long); \
    f(long long); \
    f(unsigned long long); \
    f(float); \
    f(double); \
    f(long double);

// PodType & ByteCopyType
template<class T> struct PodType : StaticBoolF { };
template<class T> struct ByteCopyType : StaticBoolF { };
#define EVO_PODTYPE(Type) template<> struct PodType<Type> : public StaticBoolT { };
EVO_APPLY_BUILTINS(EVO_PODTYPE);
#undef EVO_PODTYPE // redefined below

template<class T> struct IsPodType :
    public StaticBool<IsPointer<T>::value || PodType<typename RemoveExtentsConstVol<T>::Type>::value> { };

template<class T> struct IsByteCopyType :
    public StaticBool<IsPodType<T>::value || ByteCopyType<typename RemoveExtentsConstVol<T>::Type>::value> { };

template<class T> struct IsNormalType : public StaticBool<!IsByteCopyType<T>::value> { };


template<class T> class IsEvoContainer {
    template<class U> struct SFINAE { };
    template<class U> static char Test(SFINAE<typename U::EvoContainerType>*);
    template<class U> static long Test(...);
public:
    typedef IsEvoContainer<T> Type;    
    static const bool value = (!IsPodType<T>::value && (sizeof(Test<T>(0)) == sizeof(char) || EvoContainer<T>::value)); 
};


template<class T> class IsNullable {
    template<class U> struct SFINAE { };
    template<class U> static char Test(SFINAE<typename U::EvoNullableType>*);
    template<class U> static long Test(...);
public:
    typedef IsNullable<T> Type;    
    static const bool value = (!IsPodType<T>::value && sizeof(Test<T>(0)) == sizeof(char)) || IsEvoContainer<T>::value; 
};

namespace impl {
    template<class T, bool P=IsPointer<T>::value, bool N=IsNullable<T>::value>
    struct IsNull {
        static bool check(const T&)
            { return false; }
    };
    template<class T> struct IsNull<T,true,false> {
        static bool check(const T val)
            { return (val == NULL); }
    };
    template<class T> struct IsNull<T,false,true> {
        static bool check(const T& val)
            { return val.null(); }
    };
}
template<class T>
inline bool is_null(const T& val)
    { return impl::IsNull<T>::check(val); }


struct TypeId {
    struct Pod { };

    struct ByteCopy { };

    struct Normal { };

    enum Enum {
        POD = 0,    
        BCOPY,      
        NORMAL      
    };

    template<class T> struct Get {
        typedef typename StaticIf<IsPodType<T>::value, Pod,
            typename StaticIf<IsByteCopyType<T>::value, ByteCopy, Normal>::Type
        >::Type Id;

        static const Enum ENUM = (IsPodType<T>::value ? POD : (IsByteCopyType<T>::value ? BCOPY : NORMAL));
    };

    template<class T> struct GetFill {
        typedef typename StaticIf< IsPodType<T>::value || IsByteCopyType<T>::value,
            typename StaticIf<sizeof(T) == 1, Pod, ByteCopy>::Type,
            Normal
        >::Type Id;

        static const Enum ENUM = (IsPodType<T>::value ? POD : (IsByteCopyType<T>::value ? BCOPY : NORMAL));
    };
};

#define EVO_PODTYPE(Type) namespace evo { template<> struct PodType<Type> : public StaticBoolT { }; }

#define EVO_BCTYPE(Type) namespace evo { template<> struct ByteCopyType<Type> : public StaticBoolT { }; }

#define EVO_TYPE_SELECT(T,Pod,Bc,Normal) typename StaticIf<IsPodType<T>::value,Pod,typename StaticIf<IsByteCopyType<T>::value,Bc,Normal>::Type>::Type


#define EVO_CREATE_HAS_VAR(TypeName, VarType, VarName) \
    template<class T> class TypeName { \
        template<class U, VarType U::*> struct SFINAE { }; \
        template<class U> static char Test(SFINAE<U, &U::VarName>*); \
        template<class U> static long Test(...); \
    public: \
        static const bool value = (sizeof(Test<T>(0)) == sizeof(char)); \
    }

#define EVO_CREATE_HAS_METHOD(TypeName, ReturnType, Func, ...) \
    template<class T> class TypeName { \
        template<class U, ReturnType (U::*)(__VA_ARGS__)> struct SFINAE { }; \
        template<class U> static char Test(SFINAE<U, &U::Func>*); \
        template<class U> static long Test(...); \
    public: \
        static const bool value = (sizeof(Test<T>(0)) == sizeof(char)); \
    }

#define EVO_CREATE_HAS_METHOD_CONST(TypeName, ReturnType, Func, ...) \
    template<class T> class TypeName { \
        template<typename U, ReturnType (U::*)(__VA_ARGS__) const> struct SFINAE { }; \
        template<typename U> static char Test(SFINAE<U, &U::Func>*); \
        template<typename U> static long Test(...); \
    public: \
        static const bool value = (sizeof(Test<T>(0)) == sizeof(char)); \
    }


// ContainerType trait (used internally)
template<class T> struct ContainerType : StaticBoolF { };
#define EVO_CONTAINERTYPE(Type) template<> struct ContainerType<Type> : public StaticBoolT { };


}
#endif