forward_as.hpp

Go to the documentation of this file.

#ifndef STAN_MATH_PRIM_META_FORWARD_AS_HPP
#define STAN_MATH_PRIM_META_FORWARD_AS_HPP
 
#include <stan/math/prim/meta.hpp>
#include <type_traits>
 
namespace stan {
namespace math {
 
namespace internal {
template <typename T1, typename T2>
constexpr bool eigen_static_size_match(T1 desired, T2 actual) {
  return static_cast<int>(desired) == Eigen::Dynamic
         || static_cast<int>(desired) == static_cast<int>(actual);
}
}  // namespace internal
 
template <typename T_desired, typename T_actual,
          typename
          = std::enable_if_t<std::is_same<std::decay_t<T_actual>,
                                          std::decay_t<T_desired>>::value
                             && !is_eigen<T_desired>::value>>
inline T_actual&& forward_as(T_actual&& a) {  // NOLINT
  return std::forward<T_actual>(a);
}
 
template <
    typename T_desired, typename T_actual,
    require_any_not_eigen_t<T_desired, T_actual>* = nullptr,
    typename = std::enable_if_t<
        !std::is_same<std::decay<T_actual>, std::decay<T_desired>>::value
        && !(std::is_floating_point_v<std::decay_t<
                 T_desired>> && std::is_integral_v<std::decay_t<T_actual>>)>>
inline T_desired forward_as(const T_actual& a) {
  throw std::runtime_error("Wrong type assumed! Please file a bug report.");
}
 
template <typename T_desired, typename T_actual,
          typename = std::enable_if_t<
              std::is_floating_point_v<std::decay_t<
                  T_desired>> && std::is_integral_v<std::decay_t<T_actual>>>>
inline T_desired forward_as(const T_actual& a) {
  return static_cast<T_desired>(a);
}
 
template <
    typename T_desired, typename T_actual,
    require_eigen_t<T_desired>* = nullptr,
    std::enable_if_t<
        std::is_same<value_type_t<T_actual>, value_type_t<T_desired>>::value
        && is_eigen<T_desired>::value && is_eigen<T_actual>::value
        && internal::eigen_static_size_match(
            T_desired::RowsAtCompileTime,
            std::decay_t<T_actual>::RowsAtCompileTime)
        && internal::eigen_static_size_match(
            T_desired::ColsAtCompileTime,
            std::decay_t<T_actual>::ColsAtCompileTime)>* = nullptr>
inline T_actual&& forward_as(T_actual&& a) {  // NOLINT
  return std::forward<T_actual>(a);
}
 
template <
    typename T_desired, typename T_actual,
    require_all_eigen_t<T_desired, T_actual>* = nullptr,
    std::enable_if_t<
        !std::is_same<value_type_t<T_actual>, value_type_t<T_desired>>::value
        || !internal::eigen_static_size_match(
            T_desired::RowsAtCompileTime,
            std::decay_t<T_actual>::RowsAtCompileTime)
        || !internal::eigen_static_size_match(
            T_desired::ColsAtCompileTime,
            std::decay_t<T_actual>::ColsAtCompileTime)>* = nullptr>
inline T_desired forward_as(const T_actual& a) {
  throw std::runtime_error("Wrong type assumed! Please file a bug report.");
}
 
}  // namespace math
}  // namespace stan
#endif