integral.h

Go to the documentation of this file.

#ifndef __utl_meta_integralconstant_h__
#define __utl_meta_integralconstant_h__

#include <utl/core/impl.h>
#include <type_traits>
#include <utility>


namespace utl {
namespace meta {

   struct nil_ {
      using type = nil_;
   };

   template <typename Tp>
   using eval = typename Tp::type;

   template <typename Tp, Tp v>
   using integral_ = std::integral_constant<Tp, v>;


   template<bool v>
   using bool_ = integral_<bool, v>;

   using true_ = bool_<true>; 
   using false_ = bool_<false>; 

   template<int8_t v>
   using int8_ = integral_<int8_t, v>;
   template<uint8_t v>
   using uint8_ = integral_<uint8_t, v>;

   template<int16_t v>
   using int16_ = integral_<int16_t, v>;
   template<uint16_t v>
   using uint16_ = integral_<uint16_t, v>;

   template<int32_t v>
   using int32_ = integral_<int32_t, v>;
   template<uint32_t v>
   using uint32_ = integral_<uint32_t, v>;

   template<char v>
   using char_ = integral_<char, v>;

   template<int v>
   using int_ = integral_<int, v>;

   template<long v>
   using long_ = integral_<long, v>;

   template<index_t v>
   using index_ = integral_<index_t, v>;

   template<size_t v>
   using size_ = integral_<size_t, v>;

   template <typename Tp>
   using sizeof_ = size_<sizeof(Tp)>;

   template <typename Tp>
   using alignof_ = size_<alignof(Tp)>;

   using Npos = size_<index_t(-1)>;

   template< class Tp, Tp... Ints >
   using integer_sequence = std::integer_sequence<Tp, Ints...>;

   template<typename Tp, Tp Num>
   using make_integer_sequence  = std::make_integer_sequence<Tp, Num>;

   template<index_t... Idx>
   using index_sequence = integer_sequence<index_t, Idx...>;

   template<index_t Num>
   using make_index_sequence = make_integer_sequence <index_t, Num>;

   template<typename... Types>
   using index_sequence_for = make_index_sequence<sizeof...(Types)>;

}}


#endif /* __utl_meta_integralconstant_h__ */