type_traits.h

Go to the documentation of this file.

#pragma once

namespace illumina { namespace interop
{

    struct null_type{};

    template<class T, class U>
    struct type_list
    {
        typedef T head_t;
        typedef U tail_t;
    };
    template<
            typename T1=null_type, typename T2=null_type, typename T3=null_type, typename T4=null_type,
            typename T5=null_type, typename T6=null_type, typename T7=null_type, typename T8=null_type,
            typename T9=null_type, typename T10=null_type, typename T11=null_type, typename T12=null_type,
            typename T13=null_type, typename T14=null_type, typename T15=null_type, typename T16=null_type,
            typename T17=null_type, typename T18=null_type, typename T19=null_type, typename T20=null_type,
            typename T21=null_type, typename T22=null_type, typename T23=null_type, typename T24=null_type,
            typename T25=null_type, typename T26=null_type>
    struct make_type_list
    {
    private:
        typedef typename make_type_list<
                T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26
        >::result_t tail_result_t;
    public:
        typedef type_list<T1, tail_result_t > result_t;
    };
    template<>
    struct make_type_list<>
    {
        typedef null_type result_t;
    };
    template<class TypeList, template<class>class Transform>
    struct transform_type_list;
    template<class T1, class T2, template<class>class Transform>
    struct transform_type_list< type_list<T1, T2>, Transform >
    {
        typedef type_list< typename Transform<T1>::result_t, typename transform_type_list<T2, Transform>::result_t> result_t;
    };
    template<class T1, template<class>class Transform>
    struct transform_type_list< type_list<T1, null_type>, Transform >
    {
        typedef type_list< typename Transform<T1>::result_t, null_type> result_t;
    };
    template<template<class>class Transform>
    struct transform_type_list< null_type, Transform >
    {
        typedef null_type result_t;
    };

    struct true_type
    {
        enum{
            value = true
        };
    };
    struct false_type
    {
        enum{
            value = false
        };
    };
    template<typename T> struct is_pointer : false_type {};
    template<typename T> struct is_pointer<T*> : true_type {};
    template<typename T> struct is_const : false_type {};
    template<typename T> struct is_const<const T> : true_type {};
    template<bool B, typename T, typename F> struct conditional {  typedef T type; };
    template<typename T, typename F> struct conditional<false, T, F> { typedef F type; };
    template<typename T1, typename T2>
    struct is_same : false_type {};
    template<typename T>
    struct is_same<T,T>: true_type {};
    template<typename T1, typename T2>
    struct is_exact_binary : false_type {};
    template<typename T>
    struct is_exact_binary<T,T>: true_type {};

    template<typename T, T v>
    struct constant_type
    {
        typedef T value_t;
        typedef constant_type<T, v>* pointer_t;
        static value_t value(){ return v; }
        operator value_t()const { return v; }/*noexcept*/
        value_t operator()()const { return v; }/*noexcept*/
        static pointer_t null(){return 0;}
    };
    template<int v>
    struct int_constant_type : public constant_type<int, v>{};
}}