1 // This file is part of Eigen, a lightweight C++ template library 2 // for linear algebra. 3 // 4 // Copyright (C) 2009-2010 Gael Guennebaud <gael.guennebaud@inria.fr> 5 // Copyright (C) 2009-2010 Benoit Jacob <jacob.benoit.1@gmail.com> 6 // 7 // This Source Code Form is subject to the terms of the Mozilla 8 // Public License v. 2.0. If a copy of the MPL was not distributed 9 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 10 11 #ifndef EIGEN_RETURNBYVALUE_H 12 #define EIGEN_RETURNBYVALUE_H 13 14 namespace Eigen { 15 16 namespace internal { 17 18 template<typename Derived> 19 struct traits<ReturnByValue<Derived> > 20 : public traits<typename traits<Derived>::ReturnType> 21 { 22 enum { 23 // We're disabling the DirectAccess because e.g. the constructor of 24 // the Block-with-DirectAccess expression requires to have a coeffRef method. 25 // Also, we don't want to have to implement the stride stuff. 26 Flags = (traits<typename traits<Derived>::ReturnType>::Flags 27 | EvalBeforeNestingBit) & ~DirectAccessBit 28 }; 29 }; 30 31 /* The ReturnByValue object doesn't even have a coeff() method. 32 * So the only way that nesting it in an expression can work, is by evaluating it into a plain matrix. 33 * So internal::nested always gives the plain return matrix type. 34 * 35 * FIXME: I don't understand why we need this specialization: isn't this taken care of by the EvalBeforeNestingBit ?? 36 * Answer: EvalBeforeNestingBit should be deprecated since we have the evaluators 37 */ 38 template<typename Derived,int n,typename PlainObject> 39 struct nested_eval<ReturnByValue<Derived>, n, PlainObject> 40 { 41 typedef typename traits<Derived>::ReturnType type; 42 }; 43 44 } // end namespace internal 45 46 /** \class ReturnByValue 47 * \ingroup Core_Module 48 * 49 */ 50 template<typename Derived> class ReturnByValue 51 : public internal::dense_xpr_base< ReturnByValue<Derived> >::type, internal::no_assignment_operator 52 { 53 public: 54 typedef typename internal::traits<Derived>::ReturnType ReturnType; 55 56 typedef typename internal::dense_xpr_base<ReturnByValue>::type Base; 57 EIGEN_DENSE_PUBLIC_INTERFACE(ReturnByValue) 58 59 template<typename Dest> 60 EIGEN_DEVICE_FUNC 61 inline void evalTo(Dest& dst) const 62 { static_cast<const Derived*>(this)->evalTo(dst); } 63 EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR 64 inline Index rows() const EIGEN_NOEXCEPT { return static_cast<const Derived*>(this)->rows(); } 65 EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR 66 inline Index cols() const EIGEN_NOEXCEPT { return static_cast<const Derived*>(this)->cols(); } 67 68 #ifndef EIGEN_PARSED_BY_DOXYGEN 69 #define Unusable YOU_ARE_TRYING_TO_ACCESS_A_SINGLE_COEFFICIENT_IN_A_SPECIAL_EXPRESSION_WHERE_THAT_IS_NOT_ALLOWED_BECAUSE_THAT_WOULD_BE_INEFFICIENT 70 class Unusable{ 71 Unusable(const Unusable&) {} 72 Unusable& operator=(const Unusable&) {return *this;} 73 }; 74 const Unusable& coeff(Index) const { return *reinterpret_cast<const Unusable*>(this); } 75 const Unusable& coeff(Index,Index) const { return *reinterpret_cast<const Unusable*>(this); } 76 Unusable& coeffRef(Index) { return *reinterpret_cast<Unusable*>(this); } 77 Unusable& coeffRef(Index,Index) { return *reinterpret_cast<Unusable*>(this); } 78 #undef Unusable 79 #endif 80 }; 81 82 template<typename Derived> 83 template<typename OtherDerived> 84 EIGEN_DEVICE_FUNC Derived& DenseBase<Derived>::operator=(const ReturnByValue<OtherDerived>& other) 85 { 86 other.evalTo(derived()); 87 return derived(); 88 } 89 90 namespace internal { 91 92 // Expression is evaluated in a temporary; default implementation of Assignment is bypassed so that 93 // when a ReturnByValue expression is assigned, the evaluator is not constructed. 94 // TODO: Finalize port to new regime; ReturnByValue should not exist in the expression world 95 96 template<typename Derived> 97 struct evaluator<ReturnByValue<Derived> > 98 : public evaluator<typename internal::traits<Derived>::ReturnType> 99 { 100 typedef ReturnByValue<Derived> XprType; 101 typedef typename internal::traits<Derived>::ReturnType PlainObject; 102 typedef evaluator<PlainObject> Base; 103 104 EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr) 105 : m_result(xpr.rows(), xpr.cols()) 106 { 107 ::new (static_cast<Base*>(this)) Base(m_result); 108 xpr.evalTo(m_result); 109 } 110 111 protected: 112 PlainObject m_result; 113 }; 114 115 } // end namespace internal 116 117 } // end namespace Eigen 118 119 #endif // EIGEN_RETURNBYVALUE_H 120