chainable_object.hpp

Go to the documentation of this file.

#ifndef STAN_MATH_REV_CORE_CHAINABLE_OBJECT_HPP
#define STAN_MATH_REV_CORE_CHAINABLE_OBJECT_HPP
 
#include <stan/math/rev/meta.hpp>
#include <stan/math/rev/core/chainable_alloc.hpp>
#include <stan/math/rev/core/typedefs.hpp>
#include <stan/math/prim/fun/Eigen.hpp>
#include <stan/math/prim/fun/typedefs.hpp>
#include <vector>
 
namespace stan {
namespace math {
 
template <typename T>
class chainable_object : public chainable_alloc {
 private:
  plain_type_t<T> obj_;
 
 public:
  template <typename S,
            require_same_t<plain_type_t<T>, plain_type_t<S>>* = nullptr>
  explicit chainable_object(S&& obj) : obj_(std::forward<S>(obj)) {}
 
  inline auto& get() noexcept { return obj_; }
  inline const auto& get() const noexcept { return obj_; }
};
 
template <typename T>
auto make_chainable_ptr(T&& obj) {
  auto ptr = new chainable_object<T>(std::forward<T>(obj));
  return &ptr->get();
}
 
template <typename T>
class unsafe_chainable_object : public chainable_alloc {
 private:
  std::decay_t<T> obj_;
 
 public:
  template <typename S,
            require_same_t<plain_type_t<T>, plain_type_t<S>>* = nullptr>
  explicit unsafe_chainable_object(S&& obj) : obj_(std::forward<S>(obj)) {}
 
  inline auto& get() noexcept { return obj_; }
  inline const auto& get() const noexcept { return obj_; }
};
 
template <typename T>
auto make_unsafe_chainable_ptr(T&& obj) {
  auto ptr = new unsafe_chainable_object<T>(std::forward<T>(obj));
  return &ptr->get();
}
 
}  // namespace math
}  // namespace stan
#endif