Forwarding.h

Go to the documentation of this file.

#pragma once

 
#include <concepts>
#include <type_traits>
#include <utility>
 
#include <Eigen/Core>
 
namespace Emrys
{
 
namespace internal
{

template <typename T>
using CrtpDerived = std::remove_cvref_t<decltype(std::declval<std::remove_cvref_t<T> &>().derived())>;
 
}  // namespace internal

template <typename T>
concept MatrixExpression = requires { typename internal::CrtpDerived<T>; }
                        && std::derived_from<std::remove_cvref_t<T>, Eigen::MatrixBase<internal::CrtpDerived<T>>>;

template <typename T>
concept DiagonalExpression = std::derived_from<std::remove_cvref_t<T>, Eigen::DiagonalBase<std::remove_cvref_t<T>>>;

template <typename T>
concept CovarianceExpression = MatrixExpression<T> || DiagonalExpression<T>;
 
namespace internal
{

template <typename Scalar, MatrixExpression M>
[[nodiscard]] decltype(auto)
castScalar(M && m)
{
    if constexpr (std::is_same_v<typename std::remove_cvref_t<M>::Scalar, Scalar>)
    {
        return std::forward<M>(m);
    }
    else
    {
        return m.template cast<Scalar>();
    }
}

template <typename T, typename U>
using ConstLike = std::conditional_t<
    std::is_const_v<std::remove_reference_t<T>>,
    std::remove_reference_t<U> const,
    std::remove_reference_t<U>>;

template <typename T, typename U>
using ForwardedLike = std::conditional_t<std::is_lvalue_reference_v<T>, ConstLike<T, U> &, ConstLike<T, U> &&>;

template <typename T, typename U>
[[nodiscard]] constexpr ForwardedLike<T, U>
forwardLike(U && u) noexcept
{
    return static_cast<ForwardedLike<T, U>>(u);
}
 
}  // namespace internal
 
}  // namespace Emrys