TupleType.h

Go to the documentation of this file.

#ifndef INCLUDE_MOLASSEMBLER_TEMPLE_CONSTEXPR_TUPLE_TYPE_H
#define INCLUDE_MOLASSEMBLER_TEMPLE_CONSTEXPR_TUPLE_TYPE_H

#include "Molassembler/Temple/constexpr/Array.h"

#include <tuple>

namespace Scine {
namespace Molassembler {
namespace Temple {

namespace Tuples {
namespace Detail {

template<typename T>
constexpr auto handleValueVariants(
  std::enable_if_t<
    std::is_function<decltype(T::value)>::value,
    int
  >* /* enableIfPtr */ = nullptr
) {
  return T::value();
}

template<typename T>
constexpr auto handleValueVariants(
  std::enable_if_t<
    !std::is_function<decltype(T::value)>::value,
    int
  >* /* enableIfPtr */ = nullptr
) {
  return T::value;
}

template<
  typename Tuple,
  template<typename ...> class TemplateFunction,
  std::size_t... I
> constexpr auto unpackHelper(std::index_sequence<I...> /* inds */) {
  /* Convert the indices parameter pack into a parameter pack containing all
   * types of the tuple, and return the evaluated template function instantiated
   * with all those types
   */
  return handleValueVariants<
    TemplateFunction<
      std::tuple_element_t<I, Tuple>...
    >
  >();
}

template<
  typename TupleType,
  template<typename> class TemplateFunction,
  std::size_t... Inds
> constexpr auto mapHelper(std::index_sequence<Inds...> /* inds */) {
  return makeArray(
    handleValueVariants<
      TemplateFunction<
        std::tuple_element_t<Inds, TupleType>
      >
    >()...
  );
}

template<
  typename TupleType,
  typename T,
  std::size_t ... Inds
> constexpr unsigned countTypeHelper(
  std::index_sequence<Inds...> /* inds */
) {
  constexpr std::array<unsigned, sizeof...(Inds)> trues {{
    static_cast<unsigned>(
      std::is_same<
        std::tuple_element_t<Inds, TupleType>,
        T
      >::value
    )...
  }};

  unsigned sum = 0;

  for(unsigned long i = 0; i < sizeof...(Inds); ++i) {
    sum += trues.at(i);
  }

  return sum;
}

template<typename T>
struct RepeatTypeHelper {
  using BaseType = std::tuple<T>;

  template<std::size_t ... Inds>
  static constexpr auto value(std::index_sequence<Inds...> /* inds */)
  -> std::tuple<std::tuple_element_t<Inds * 0, BaseType>...> {}
};

} // namespace Detail

template<
  typename Tuple,
  template<typename ...> class TemplateFunction
> constexpr auto unpackToFunction() {
  return Detail::unpackHelper<Tuple, TemplateFunction>(
    std::make_index_sequence<
      std::tuple_size<Tuple>::value
    >()
  );
}

template<
  typename TupleType,
  template<typename> class TemplateFunction
> constexpr auto map() {
  return Detail::mapHelper<TupleType, TemplateFunction>(
    std::make_index_sequence<
      std::tuple_size<TupleType>::value
    >()
  );
}

template<
  typename TupleType,
  typename T
> constexpr unsigned countType() {
  return Detail::countTypeHelper<TupleType, T>(
    std::make_index_sequence<
      std::tuple_size<TupleType>::value
    >()
  );
}

template<
  typename TupleType,
  template<typename> class UnaryPredicate
> constexpr bool allOf() {
  constexpr size_t N = std::tuple_size<TupleType>::value;
  constexpr auto mapped = map<TupleType, UnaryPredicate>();
  for(unsigned i = 0; i < N; ++i) {
    if(!mapped.at(i)) {
      return false;
    }
  }

  return true;
}

template<typename T, unsigned repeats>
struct RepeatType {
  using type = decltype(
    Detail::RepeatTypeHelper<T>::value(
      std::make_index_sequence<repeats>()
    )
  );
};

} // namespace Tuples
} // namespace Temple
} // namespace Molassembler
} // namespace Scine

#endif