mesh_function_traits.h

 
#ifndef INCG7e4ffaa81e244723acbfbbaea68e03b1
#define INCG7e4ffaa81e244723acbfbbaea68e03b1
 
#include <lf/mesh/mesh.h>
 
#include <concepts>
#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>
  requires(!std::is_same_v<VectorElement_t<MeshFunctionReturnType_t<T>>, void>)
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 MF, class R = void>
concept MeshFunction =
    // @note We use IsMeshFunctionCallable here because otherwise e.g.
    // Eigen::Matrix also fulfills the concept of a MeshFunction (even though it
    // leads to compile errors during instantiation)
    std::is_object_v<MF> && std::copy_constructible<MF> &&
    internal::IsMeshFunctionCallable<MF, R>(0);
 
template <class R>
struct MeshFunctionAT {
  MeshFunctionAT(const MeshFunctionAT&) noexcept = default;
 
  MeshFunctionAT(MeshFunctionAT&&) noexcept = default;
 
  auto operator=(const MeshFunctionAT&) noexcept -> MeshFunctionAT& = delete;
 
  auto operator=(MeshFunctionAT&&) noexcept -> MeshFunctionAT& = delete;
 
  ~MeshFunctionAT() noexcept = default;
 
  // NOLINTBEGIN(misc-unused-parameters)
  std::vector<R> operator()(const Entity& e,
                            const Eigen::MatrixXd& local) const {
    // NOLINTEND(misc-unused-parameters)
    LF_VERIFY_MSG(false, "Should never be called, this is an archetype");
    return {};
  }
};
 
template <class R>
using MeshFunctionReturnType =
    internal::VectorElement_t<internal::MeshFunctionReturnType_t<R>>;
 
}  // namespace lf::mesh::utils
 
#endif  // INCG7e4ffaa81e244723acbfbbaea68e03b1