metaprog.hpp

Go to the documentation of this file.

/* 
 * This file is part of PLaSK (https://plask.app) by Photonics Group at TUL
 * Copyright (c) 2022 Lodz University of Technology
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 */
#ifndef PLASK__UTILS_METAPROG_H
#define PLASK__UTILS_METAPROG_H
 
#include <tuple>
#include <type_traits>
 
namespace plask {
 
template <int nr, typename... types>
struct chooseType {
    typedef typename std::tuple_element<nr, std::tuple<types...>>::type type;
};
 
//TODO better impl. but not compilable with GCC 4.6 (unimplemented)
/*template <int nr, typename firstType, typename... restTypes> struct chooseType {
    typedef typename chooseType<nr-1, restTypes...>::type type;
};
 
template <typename firstType, typename... restTypes> struct chooseType<0, firstType, restTypes...> {
    typedef firstType type;
};*/
 
 
//http://talesofcpp.fusionfenix.com/post-11/true-story-call-me-maybe
namespace hyman {
  template <typename T>
  using always_void = void;
 
  template <typename Expr, std::size_t Step = 0, typename Enable = void>
  struct is_callable_impl
    : is_callable_impl<Expr, Step + 1>
  {};
 
  // (t1.*f)(t2, ..., tN) when f is a pointer to a member function of a class T
  // and t1 is an object of type T or a reference to an object of type T or a
  // reference to an object of a type derived from T;
  template <typename F, typename T, typename ...Args>
  struct is_callable_impl<F(T, Args...), 0,
    always_void<decltype(
      (std::declval<T>().*std::declval<F>())(std::declval<Args>()...)
    )>
  > : std::true_type
  {};
 
  // ((*t1).*f)(t2, ..., tN) when f is a pointer to a member function of a class T
  // and t1 is not one of the types described in the previous item;
  template <typename F, typename T, typename ...Args>
  struct is_callable_impl<F(T, Args...), 1,
    always_void<decltype(
      ((*std::declval<T>()).*std::declval<F>())(std::declval<Args>()...)
    )>
  > : std::true_type
  {};
 
  // t1.*f when N == 1 and f is a pointer to member data of a class T and t1 is an
  // object of type T or a reference to an object of type T or a reference to an
  // object of a type derived from T;
  template <typename F, typename T>
  struct is_callable_impl<F(T), 2,
    always_void<decltype(
      std::declval<T>().*std::declval<F>()
    )>
  > : std::true_type
  {};
 
  // (*t1).*f when N == 1 and f is a pointer to member data of a class T and t1 is
  // not one of the types described in the previous item;
  template <typename F, typename T>
  struct is_callable_impl<F(T), 3,
    always_void<decltype(
      (*std::declval<T>()).*std::declval<F>()
    )>
  > : std::true_type
  {};
 
  // f(t1, t2, ..., tN) in all other cases.
  template <typename F, typename ...Args>
  struct is_callable_impl<F(Args...), 4,
    always_void<decltype(
      std::declval<F>()(std::declval<Args>()...)
    )>
  > : std::true_type
  {};
 
  template <typename Expr>
  struct is_callable_impl<Expr, 5>
    : std::false_type
  {};
}
 
template <typename Expr>
struct is_callable
  : hyman::is_callable_impl<Expr>
{};
 
 
}   // namespace plask
 
 
#endif // PLASK__UTILS_METAPROG_H