From 8473a77f2fc3461a4d93de08cda4a50a62ca0abe Mon Sep 17 00:00:00 2001
From: Gael Guennebaud <g.gael@free.fr>
Date: Sat, 13 Sep 2008 18:51:51 +0000
Subject: move CommaInitializer out of MatrixBase and documment it (because of
 .finished())

---
 Eigen/src/Core/CommaInitializer.h         | 44 ++++++++++++++++++++-----------
 Eigen/src/Core/MatrixBase.h               |  6 ++---
 Eigen/src/Core/Redux.h                    |  5 ++--
 Eigen/src/Core/util/ForwardDeclarations.h |  2 ++
 4 files changed, 34 insertions(+), 23 deletions(-)

(limited to 'Eigen')

diff --git a/Eigen/src/Core/CommaInitializer.h b/Eigen/src/Core/CommaInitializer.h
index 282510550..4aa1fcd0a 100644
--- a/Eigen/src/Core/CommaInitializer.h
+++ b/Eigen/src/Core/CommaInitializer.h
@@ -26,25 +26,34 @@
 #ifndef EIGEN_COMMAINITIALIZER_H
 #define EIGEN_COMMAINITIALIZER_H
 
-/** \internal
-  * Helper class to define the MatrixBase::operator<<
+/** \class CommaInitializer
+  * 
+  * \brief Helper class used by the comma initializer operator
+  *
+  * This class is internally used to implement the comma initializer feature. It is
+  * the return type of MatrixBase::operator<<, and most of the time this is the only
+  * way it is used.
+  * 
+  * \sa \ref MatrixBaseCommaInitRef "MatrixBase::operator<<", CommaInitializer::finished()
   */
-template<typename Derived>
-struct MatrixBase<Derived>::CommaInitializer
+template<typename MatrixType>
+struct CommaInitializer
 {
-  inline CommaInitializer(Derived& mat, const Scalar& s)
+  typedef typename ei_traits<MatrixType>::Scalar Scalar;
+  inline CommaInitializer(MatrixType& mat, const Scalar& s)
     : m_matrix(mat), m_row(0), m_col(1), m_currentBlockRows(1)
   {
     m_matrix.coeffRef(0,0) = s;
   }
 
   template<typename OtherDerived>
-  inline CommaInitializer(Derived& mat, const MatrixBase<OtherDerived>& other)
+  inline CommaInitializer(MatrixType& mat, const MatrixBase<OtherDerived>& other)
     : m_matrix(mat), m_row(0), m_col(other.cols()), m_currentBlockRows(other.rows())
   {
     m_matrix.block(0, 0, other.rows(), other.cols()) = other;
   }
 
+  /* inserts a scalar value in the target matrix */
   CommaInitializer& operator,(const Scalar& s)
   {
     if (m_col==m_matrix.cols())
@@ -62,6 +71,7 @@ struct MatrixBase<Derived>::CommaInitializer
     return *this;
   }
 
+  /* inserts a matrix expression in the target matrix */
   template<typename OtherDerived>
   CommaInitializer& operator,(const MatrixBase<OtherDerived>& other)
   {
@@ -77,8 +87,8 @@ struct MatrixBase<Derived>::CommaInitializer
       && "Too many coefficients passed to comma initializer (operator<<)");
     ei_assert(m_currentBlockRows==other.rows());
     if (OtherDerived::SizeAtCompileTime != Dynamic)
-      m_matrix.block<OtherDerived::RowsAtCompileTime != Dynamic ? OtherDerived::RowsAtCompileTime : 1,
-                     OtherDerived::ColsAtCompileTime != Dynamic ? OtherDerived::ColsAtCompileTime : 1>
+      m_matrix.template block<OtherDerived::RowsAtCompileTime != Dynamic ? OtherDerived::RowsAtCompileTime : 1,
+                              OtherDerived::ColsAtCompileTime != Dynamic ? OtherDerived::ColsAtCompileTime : 1>
                     (m_row, m_col) = other;
     else
       m_matrix.block(m_row, m_col, other.rows(), other.cols()) = other;
@@ -100,11 +110,11 @@ struct MatrixBase<Derived>::CommaInitializer
     * quaternion.fromRotationMatrix((Matrix3f() << axis0, axis1, axis2).finished());
     * \endcode
     */
-  inline Derived& finished() { return m_matrix; }
+  inline MatrixType& finished() { return m_matrix; }
 
-  Derived& m_matrix;
-  int m_row; // current row id
-  int m_col; // current col id
+  MatrixType& m_matrix;   // target matrix
+  int m_row;              // current row id
+  int m_col;              // current col id
   int m_currentBlockRows; // current block height
 };
 
@@ -118,20 +128,22 @@ struct MatrixBase<Derived>::CommaInitializer
   *
   * Example: \include MatrixBase_set.cpp
   * Output: \verbinclude MatrixBase_set.out
+  * 
+  * \sa CommaInitializer::finished(), class CommaInitializer
   */
 template<typename Derived>
-inline typename MatrixBase<Derived>::CommaInitializer MatrixBase<Derived>::operator<< (const Scalar& s)
+inline CommaInitializer<Derived> MatrixBase<Derived>::operator<< (const Scalar& s)
 {
-  return CommaInitializer(*static_cast<Derived*>(this), s);
+  return CommaInitializer<Derived>(*static_cast<Derived*>(this), s);
 }
 
 /** \sa operator<<(const Scalar&) */
 template<typename Derived>
 template<typename OtherDerived>
-inline typename MatrixBase<Derived>::CommaInitializer
+inline CommaInitializer<Derived>
 MatrixBase<Derived>::operator<<(const MatrixBase<OtherDerived>& other)
 {
-  return CommaInitializer(*static_cast<Derived *>(this), other);
+  return CommaInitializer<Derived>(*static_cast<Derived *>(this), other);
 }
 
 #endif // EIGEN_COMMAINITIALIZER_H
diff --git a/Eigen/src/Core/MatrixBase.h b/Eigen/src/Core/MatrixBase.h
index 81aae3593..2b4926082 100644
--- a/Eigen/src/Core/MatrixBase.h
+++ b/Eigen/src/Core/MatrixBase.h
@@ -53,8 +53,6 @@
   */
 template<typename Derived> class MatrixBase
 {
-    struct CommaInitializer;
-
   public:
 
     class InnerIterator;
@@ -236,10 +234,10 @@ template<typename Derived> class MatrixBase
     template<typename Derived1, typename Derived2>
     Derived& lazyAssign(const Product<Derived1,Derived2,SparseProduct>& product);
 
-    CommaInitializer operator<< (const Scalar& s);
+    CommaInitializer<Derived> operator<< (const Scalar& s);
 
     template<typename OtherDerived>
-    CommaInitializer operator<< (const MatrixBase<OtherDerived>& other);
+    CommaInitializer<Derived> operator<< (const MatrixBase<OtherDerived>& other);
 
     const Scalar coeff(int row, int col) const;
     const Scalar operator()(int row, int col) const;
diff --git a/Eigen/src/Core/Redux.h b/Eigen/src/Core/Redux.h
index 32b571e4f..6e4f9897d 100644
--- a/Eigen/src/Core/Redux.h
+++ b/Eigen/src/Core/Redux.h
@@ -91,9 +91,8 @@ MatrixBase<Derived>::redux(const BinaryOp& func) const
   const bool unroll = SizeAtCompileTime * CoeffReadCost
                     + (SizeAtCompileTime-1) * ei_functor_traits<BinaryOp>::Cost
                     <= EIGEN_UNROLLING_LIMIT;
-  return ei_redux_impl<BinaryOp, Derived, 0,
-                            unroll ? int(SizeAtCompileTime) : Dynamic>
-          ::run(derived(), func);
+  return ei_redux_impl<BinaryOp, Derived, 0, unroll ? int(SizeAtCompileTime) : Dynamic>
+            ::run(derived(), func);
 }
 
 /** \returns the minimum of all coefficients of *this
diff --git a/Eigen/src/Core/util/ForwardDeclarations.h b/Eigen/src/Core/util/ForwardDeclarations.h
index 8a8beb9b7..55016e05d 100644
--- a/Eigen/src/Core/util/ForwardDeclarations.h
+++ b/Eigen/src/Core/util/ForwardDeclarations.h
@@ -51,6 +51,8 @@ template<typename MatrixType, unsigned int Mode> class Part;
 template<typename MatrixType, unsigned int Mode> class Extract;
 template<typename ExpressionType> class Cwise;
 template<typename ExpressionType> class WithFormat;
+template<typename MatrixType> struct CommaInitializer;
+
 
 template<typename Lhs, typename Rhs> struct ei_product_mode;
 template<typename Lhs, typename Rhs, int ProductMode = ei_product_mode<Lhs,Rhs>::value> struct ProductReturnType;
-- 
cgit v1.2.3