Mpl.hpp

#pragma once

// std c++ headers
#include <tuple>
#include <type_traits>
#include <utility>

namespace AMDiS
{
  // introduce some shortcuts for integral constants
  // ---------------------------------------------------------------------------

  /// A wrapper for int type
  template <int I>
  using int_t = std::integral_constant<int, I>;

  /// Variable template to generate int-type
  template <int I>
  constexpr int_t<I> int_ = {};

  /// class that represents a sequence of integers
  template <int... I>
  using Ints = std::integer_sequence<int, I...>;

  template <std::size_t I, int... J>
  auto get(Ints<J...>) { return std::get<I>(std::make_tuple(int_<J>...)); }


  /// A wrapper for std::size_t type
  template <std::size_t I>
  using index_t = std::integral_constant<std::size_t, I>;

  /// Variable template to generate std::size_t-type
  template <std::size_t I>
  constexpr index_t<I> index_ = {};


  /// class that represents a sequence of indices
  template <std::size_t... I>
  using Indices = std::index_sequence<I...>;

  template <std::size_t I, std::size_t... J>
  auto get(Indices<J...>) { return std::get<I>(std::make_tuple(index_<J>...)); }


  /// A wrapper for bool types
  template <bool B>
  using bool_t  = std::integral_constant<bool, B>;

  /// Variable template to generate bool type
  template <bool B>
  constexpr bool_t<B> bool_ = {};

  static constexpr bool_t<true>  _true  {};
  static constexpr bool_t<false> _false {};


  namespace Impl
  {
    /// A range of indices [I,J)
    template <class Int, Int I, Int J>
    struct range_impl
    {
      using type = range_impl;

      /// Return the first element in the range
      static constexpr auto begin() { return std::integral_constant<Int, I>{}; }

      /// Returns the element after the last element in the range
      static constexpr auto end() { return std::integral_constant<Int, J>{}; }

      /// Returns the ith index in the range as integral constant
      template <std::size_t i>
      constexpr auto operator[](index_t<i>) const
      {
        return std::integral_constant<Int, I+Int(i)>{};
      }

      /// Return whether the range is empty
      static constexpr bool empty() { return I >= J; }

      /// Returns the size of the range
      static constexpr auto size() { return std::integral_constant<Int, J-I>{}; }
    };

    /// Extracts the Ith element element from the range
    template <std::size_t I, class Int, Int begin, Int end>
    constexpr auto get(range_impl<Int, begin, end> const& r) { return r[index_<I>]; }

  } // end namespace Impl

  template <std::size_t I, std::size_t J>
  using range_t = Impl::range_impl<std::size_t, I, J>;

  template <std::size_t I, std::size_t J>
  constexpr range_t<I,J> range_ = {};

  // some boolean operations
  // ---------------------------------------------------------------------------

  namespace Impl
  {
    template <bool...> struct all_helper {};

  } // end namespace Impl

  template <bool... Bs>
  using all_of_t = std::is_same<Impl::all_helper<true, Bs...>, Impl::all_helper<Bs..., true>>;

  template <bool... Bs>
  constexpr bool all_of_v = all_of_t<Bs...>::value;

  template <bool... Bs>
  using and_t = all_of_t<Bs...>;

  template <bool... Bs>
  using none_of_t = std::is_same<Impl::all_helper<false, Bs...>, Impl::all_helper<Bs..., false>>;

  template <bool... Bs>
  constexpr bool none_of_v = none_of_t<Bs...>::value;

  template <bool... Bs>
  using any_of_t = bool_t<not none_of_t<Bs...>::value>;

  template <bool... Bs>
  constexpr bool any_of_v = any_of_t<Bs...>::value;

  template <bool... Bs>
  using or_t = any_of_t<Bs...>;


  template <bool... Bs>
  constexpr bool_t<and_t<Bs...>::value> and_ = {};

  template <bool B0, bool B1>
  constexpr bool_t<B0 && B1> operator&&(bool_t<B0>, bool_t<B1>) { return {}; }


  template <bool... Bs>
  constexpr bool_t<or_t<Bs...>::value> or_ = {};

  template <bool B0, bool B1>
  constexpr bool_t<B0 || B1> operator||(bool_t<B0>, bool_t<B1>) { return {}; }


  template <bool B>
  using not_t = bool_t<!B>;

  template <bool B>
  constexpr bool_t<not_t<B>::value> not_ = {};

  template <bool B>
  constexpr bool_t<!B> operator!(bool_t<B>) { return {}; }


  template <class T, T value0, T... values>
  using is_equal = all_of_t<(value0 == values)...>;

  template <class T, class... Ts>
  using is_one_of = or_t<std::is_same<T, Ts>::value...>;

} // end namespace AMDiS