mesh_function_traits.h

 
#ifndef __7e4ffaa81e244723acbfbbaea68e03b1
#define __7e4ffaa81e244723acbfbbaea68e03b1
 
#include <lf/mesh/mesh.h>
 
#include <type_traits>
 
namespace lf::mesh::utils {
namespace internal {
 
// TODO(craffael): Replace this with std::invoke_result_t once issue in msvc is
// fixed: https://github.com/microsoft/STL/issues/1288
template <class T>
using MeshFunctionReturnType_t = decltype(std::declval<T>()(
    std::declval<const Entity>(), std::declval<const Eigen::MatrixXd>()));
 
template <typename>
struct VectorElementType {
  using type = void;
};
 
template <typename T, typename A>
struct VectorElementType<std::vector<T, A>> {
  using type = T;
};
 
template <class T>
using VectorElement_t = typename VectorElementType<T>::type;
 
template <class T, class RETURN_TYPE,
          class = typename std::enable_if<!std::is_same_v<
              VectorElement_t<MeshFunctionReturnType_t<T>>, void>>::type>
constexpr bool IsMeshFunctionCallable(int /*unused*/) {
  if constexpr (std::is_same_v<RETURN_TYPE, void>) {
    // user didn't want us to check whether the return type is something
    // particular
    return true;
  }
  // user specified a RETURN_TYPE -> Check that std::vector<RETURN_TYPE> is
  // returned.
  return std::is_same_v<VectorElement_t<MeshFunctionReturnType_t<T>>,
                        RETURN_TYPE>;
}
 
template <class T, class RETURN_TYPE>
constexpr bool IsMeshFunctionCallable(long /*unused*/) {
  return false;
}
 
}  // namespace internal
 
template <class T, class R = void>
inline constexpr bool isMeshFunction =
    !std::is_reference_v<T> && std::is_copy_constructible_v<T> &&
    std::is_move_constructible_v<T> &&
    internal::IsMeshFunctionCallable<T, R>(0);
 
template <class R>
using MeshFunctionReturnType =
    internal::VectorElement_t<internal::MeshFunctionReturnType_t<R>>;
 
}  // namespace lf::mesh::utils
 
#endif  // __7e4ffaa81e244723acbfbbaea68e03b1