Introduce internal::LinearOperator namespace

diff --git a/include/deal.II/lac/block_vector.h b/include/deal.II/lac/block_vector.h
index 387645e4b93d457687f818b3d3907afee416f49e..d7013ee2a92c993a4eb8f2138b1aa5540f33a00a 100644 (file)
--- a/include/deal.II/lac/block_vector.h
+++ b/include/deal.II/lac/block_vector.h
@@ -462,47 +462,50 @@ void swap (BlockVector<Number> &u,
 
 namespace internal
 {
-  template <typename> class ReinitRangeFactory;
-  template <typename> class ReinitDomainFactory;
-
-  /*
-   * A factory class internally used in linear_operator.h.
-   * Specialization for BlockVector<number>.
-   */
-  template<typename number>
-  class ReinitRangeFactory<BlockVector<number> >
+  namespace LinearOperator
   {
-  public:
-    template <typename Matrix>
-    std::function<void(BlockVector<number> &, bool)>
-    operator()(const Matrix &matrix)
+    template <typename> class ReinitRangeFactory;
+    template <typename> class ReinitDomainFactory;
+
+    /**
+     * A factory class internally used in linear_operator.h.
+     * Specialization for BlockVector<number>.
+     */
+    template<typename number>
+    class ReinitRangeFactory<BlockVector<number> >
     {
-      return [&matrix](BlockVector<number> &v, bool fast)
+    public:
+      template <typename Matrix>
+      std::function<void(BlockVector<number> &, bool)>
+      operator()(const Matrix &matrix)
       {
-        v.reinit(matrix.get_row_indices(), fast);
-      };
-    }
-  };
-
-  /*
-   * A factory class internally used in linear_operator.h.
-   * Specialization for BlockVector<number>.
-   */
-  template<typename number>
-  class ReinitDomainFactory<BlockVector<number> >
-  {
-  public:
-    template <typename Matrix>
-    std::function<void(BlockVector<number> &, bool)>
-    operator()(const Matrix &matrix)
+        return [&matrix](BlockVector<number> &v, bool fast)
+        {
+          v.reinit(matrix.get_row_indices(), fast);
+        };
+      }
+    };
+
+    /**
+     * A factory class internally used in linear_operator.h.
+     * Specialization for BlockVector<number>.
+     */
+    template<typename number>
+    class ReinitDomainFactory<BlockVector<number> >
     {
-      return [&matrix](BlockVector<number> &v, bool fast)
+    public:
+      template <typename Matrix>
+      std::function<void(BlockVector<number> &, bool)>
+      operator()(const Matrix &matrix)
       {
-        v.reinit(matrix.get_column_indices(), fast);
-      };
-    }
-  };
-}
+        return [&matrix](BlockVector<number> &v, bool fast)
+        {
+          v.reinit(matrix.get_column_indices(), fast);
+        };
+      }
+    };
+  } /* namespace LinearOperator */
+} /* namespace internal */
 
 DEAL_II_NAMESPACE_CLOSE
 

diff --git a/include/deal.II/lac/linear_operator.h b/include/deal.II/lac/linear_operator.h
index 02308f399765a97bf058dc174bbd6ce8b99183d5..f7dc617b62148d264e487d80291198159c36aaf0 100644 (file)
--- a/include/deal.II/lac/linear_operator.h
+++ b/include/deal.II/lac/linear_operator.h
@@ -905,56 +905,59 @@ blockdiag_linop(const LinearOperator<typename Range::BlockType, typename Domain:
 
 namespace internal
 {
-  /*
-   * A factory class that is responsible for the creation of a
-   * reinit_range_vector object for a given pair of vector type Range and matrix
-   * type Matrix.
-   *
-   * The generic version of this class just calls
-   * <code>Range::reinit()</code> with the result of
-   * <code>Matrix::m()</code>. This class is specialized for more complicated
-   * data structures, such as TrilinosWrappers::MPI::Vector, etc.
-   */
-  template<typename Range>
-  class ReinitRangeFactory
+  namespace LinearOperator
   {
-  public:
-    template <typename Matrix>
-    std::function<void(Range &, bool)>
-    operator()(const Matrix &matrix)
+    /**
+     * A factory class that is responsible for the creation of a
+     * reinit_range_vector object for a given pair of vector type Range and matrix
+     * type Matrix.
+     *
+     * The generic version of this class just calls
+     * <code>Range::reinit()</code> with the result of
+     * <code>Matrix::m()</code>. This class is specialized for more complicated
+     * data structures, such as TrilinosWrappers::MPI::Vector, etc.
+     */
+    template<typename Range>
+    class ReinitRangeFactory
     {
-      return [&matrix](Range &v, bool fast)
+    public:
+      template <typename Matrix>
+      std::function<void(Range &, bool)>
+      operator()(const Matrix &matrix)
       {
-        v.reinit(matrix.m(), fast);
-      };
-    }
-  };
+        return [&matrix](Range &v, bool fast)
+        {
+          v.reinit(matrix.m(), fast);
+        };
+      }
+    };
 
 
-  /*
-   * A factory class that is responsible for the creation of a
-   * reinit_domain_vector object for a given pair of vector type Domain and
-   * matrix type Matrix.
-   *
-   * The generic version of this class just calls
-   * <code>Domain::reinit()</code> with the result of
-   * <code>Matrix::n()</code>. This class is specialized for more complicated
-   * data structures, such as TrilinosWrappers::MPI::Vector, etc.
-   */
-  template<typename Domain>
-  class ReinitDomainFactory
-  {
-  public:
-    template <typename Matrix>
-    std::function<void(Domain &, bool)>
-    operator()(const Matrix &matrix)
+    /**
+     * A factory class that is responsible for the creation of a
+     * reinit_domain_vector object for a given pair of vector type Domain and
+     * matrix type Matrix.
+     *
+     * The generic version of this class just calls
+     * <code>Domain::reinit()</code> with the result of
+     * <code>Matrix::n()</code>. This class is specialized for more complicated
+     * data structures, such as TrilinosWrappers::MPI::Vector, etc.
+     */
+    template<typename Domain>
+    class ReinitDomainFactory
     {
-      return [&matrix](Domain &v, bool fast)
+    public:
+      template <typename Matrix>
+      std::function<void(Domain &, bool)>
+      operator()(const Matrix &matrix)
       {
-        v.reinit(matrix.n(), fast);
-      };
-    }
-  };
+        return [&matrix](Domain &v, bool fast)
+        {
+          v.reinit(matrix.n(), fast);
+        };
+      }
+    };
+  } /* namespace LinearOperator */
 } /* namespace internal */
 
 
@@ -1165,10 +1168,10 @@ LinearOperator<Range, Domain> linop(const Exemplar &exemplar,
   // or an exemplar cannot usually be copied...
 
   return_op.reinit_range_vector =
-    internal::ReinitRangeFactory<Range>().operator()(exemplar);
+    internal::LinearOperator::ReinitRangeFactory<Range>().operator()(exemplar);
 
   return_op.reinit_domain_vector =
-    internal::ReinitDomainFactory<Domain>().operator()(exemplar);
+    internal::LinearOperator::ReinitDomainFactory<Domain>().operator()(exemplar);
 
   typename std::conditional<
   has_vmult_add<Range, Domain, Matrix>::type::value,

diff --git a/include/deal.II/lac/trilinos_block_vector.h b/include/deal.II/lac/trilinos_block_vector.h
index be7f29cc35b1bc3d4af890703ff9b3cd17b36b78..0a820a05caebb01a64f26df2de0612eabdc73843 100644 (file)
--- a/include/deal.II/lac/trilinos_block_vector.h
+++ b/include/deal.II/lac/trilinos_block_vector.h
@@ -454,46 +454,49 @@ namespace TrilinosWrappers
 
 namespace internal
 {
-  template <typename> class ReinitRangeFactory;
-  template <typename> class ReinitDomainFactory;
-
-  /*
-   * A factory class internally used in linear_operator.h.
-   * Specialization for TrilinosWrappers::BlockVector.
-   */
-  template<>
-  class ReinitRangeFactory<TrilinosWrappers::BlockVector>
+  namespace LinearOperator
   {
-  public:
-    template <typename Matrix>
-    std::function<void(TrilinosWrappers::BlockVector &, bool)>
-    operator()(const Matrix &matrix)
+    template <typename> class ReinitRangeFactory;
+    template <typename> class ReinitDomainFactory;
+
+    /**
+     * A factory class internally used in linear_operator.h. Specialization
+     * for TrilinosWrappers::BlockVector.
+     */
+    template<>
+    class ReinitRangeFactory<TrilinosWrappers::BlockVector>
     {
-      return [&matrix](TrilinosWrappers::BlockVector &v, bool fast)
+    public:
+      template <typename Matrix>
+      std::function<void(TrilinosWrappers::BlockVector &, bool)>
+      operator()(const Matrix &matrix)
       {
-        v.reinit(matrix.range_partitioner(), fast);
-      };
-    }
-  };
+        return [&matrix](TrilinosWrappers::BlockVector &v, bool fast)
+        {
+          v.reinit(matrix.range_partitioner(), fast);
+        };
+      }
+    };
 
-  /*
-   * A factory class internally used in linear_operator.h.
-   * Specialization for TrilinosWrappers::BlockVector.
-   */
-  template<>
-  class ReinitDomainFactory<TrilinosWrappers::BlockVector>
-  {
-  public:
-    template <typename Matrix>
-    std::function<void(TrilinosWrappers::BlockVector &, bool)>
-    operator()(const Matrix &matrix)
+    /**
+     * A factory class internally used in linear_operator.h. Specialization
+     * for TrilinosWrappers::BlockVector.
+     */
+    template<>
+    class ReinitDomainFactory<TrilinosWrappers::BlockVector>
     {
-      return [&matrix](TrilinosWrappers::BlockVector &v, bool fast)
+    public:
+      template <typename Matrix>
+      std::function<void(TrilinosWrappers::BlockVector &, bool)>
+      operator()(const Matrix &matrix)
       {
-        v.reinit(matrix.domain_partitioner(), fast);
-      };
-    }
-  };
+        return [&matrix](TrilinosWrappers::BlockVector &v, bool fast)
+        {
+          v.reinit(matrix.domain_partitioner(), fast);
+        };
+      }
+    };
+  } /* namespace LinearOperator */
 } /* namespace internal */
 
 DEAL_II_NAMESPACE_CLOSE

diff --git a/include/deal.II/lac/trilinos_parallel_block_vector.h b/include/deal.II/lac/trilinos_parallel_block_vector.h
index b2fe52a8f95c29569dfb5f03b30ca66f80e1f31f..f1d102b1866230cd34f02c8999ebd8c0e26c6bf9 100644 (file)
--- a/include/deal.II/lac/trilinos_parallel_block_vector.h
+++ b/include/deal.II/lac/trilinos_parallel_block_vector.h
@@ -468,46 +468,49 @@ namespace TrilinosWrappers
 
 namespace internal
 {
-  template <typename> class ReinitRangeFactory;
-  template <typename> class ReinitDomainFactory;
-
-  /*
-   * A factory class internally used in linear_operator.h.
-   * Specialization for TrilinosWrappers::MPI::BlockVector.
-   */
-  template<>
-  class ReinitRangeFactory<TrilinosWrappers::MPI::BlockVector>
+  namespace LinearOperator
   {
-  public:
-    template <typename Matrix>
-    std::function<void(TrilinosWrappers::MPI::BlockVector &, bool)>
-    operator()(const Matrix &matrix)
+    template <typename> class ReinitRangeFactory;
+    template <typename> class ReinitDomainFactory;
+
+    /**
+     * A factory class internally used in linear_operator.h. Specialization
+     * for TrilinosWrappers::MPI::BlockVector.
+     */
+    template<>
+    class ReinitRangeFactory<TrilinosWrappers::MPI::BlockVector>
     {
-      return [&matrix](TrilinosWrappers::MPI::BlockVector &v, bool fast)
+    public:
+      template <typename Matrix>
+      std::function<void(TrilinosWrappers::MPI::BlockVector &, bool)>
+      operator()(const Matrix &matrix)
       {
-        v.reinit(matrix.range_partitioner(), fast);
-      };
-    }
-  };
-
-  /*
-   * A factory class internally used in linear_operator.h.
-   * Specialization for TrilinosWrappers::MPI::BlockVector.
-   */
-  template<>
-  class ReinitDomainFactory<TrilinosWrappers::MPI::BlockVector>
-  {
-  public:
-    template <typename Matrix>
-    std::function<void(TrilinosWrappers::MPI::BlockVector &, bool)>
-    operator()(const Matrix &matrix)
+        return [&matrix](TrilinosWrappers::MPI::BlockVector &v, bool fast)
+        {
+          v.reinit(matrix.range_partitioner(), fast);
+        };
+      }
+    };
+
+    /**
+     * A factory class internally used in linear_operator.h. Specialization
+     * for TrilinosWrappers::MPI::BlockVector.
+     */
+    template<>
+    class ReinitDomainFactory<TrilinosWrappers::MPI::BlockVector>
     {
-      return [&matrix](TrilinosWrappers::MPI::BlockVector &v, bool fast)
+    public:
+      template <typename Matrix>
+      std::function<void(TrilinosWrappers::MPI::BlockVector &, bool)>
+      operator()(const Matrix &matrix)
       {
-        v.reinit(matrix.domain_partitioner(), fast);
-      };
-    }
-  };
+        return [&matrix](TrilinosWrappers::MPI::BlockVector &v, bool fast)
+        {
+          v.reinit(matrix.domain_partitioner(), fast);
+        };
+      }
+    };
+  } /* namespace LinearOperator */
 } /* namespace internal */
 
 

diff --git a/include/deal.II/lac/trilinos_vector.h b/include/deal.II/lac/trilinos_vector.h
index 8868c1df11f29928279d241de06ca04ecd2a1a80..0eca9b62543b2618c7330f4ed75cc36feed1593d 100644 (file)
--- a/include/deal.II/lac/trilinos_vector.h
+++ b/include/deal.II/lac/trilinos_vector.h
@@ -942,84 +942,87 @@ namespace TrilinosWrappers
 
 namespace internal
 {
-  template <typename> class ReinitRangeFactory;
-  template <typename> class ReinitDomainFactory;
-
-  /*
-   * A factory class internally used in linear_operator.h.
-   * Specialization for TrilinosWrappers::MPI::Vector.
-   */
-  template<>
-  class ReinitRangeFactory<TrilinosWrappers::MPI::Vector>
+  namespace LinearOperator
   {
-  public:
-    template <typename Matrix>
-    std::function<void(TrilinosWrappers::MPI::Vector &, bool)>
-    operator()(const Matrix &matrix)
+    template <typename> class ReinitRangeFactory;
+    template <typename> class ReinitDomainFactory;
+
+    /**
+     * A factory class internally used in linear_operator.h. Specialization
+     * for TrilinosWrappers::MPI::Vector.
+     */
+    template<>
+    class ReinitRangeFactory<TrilinosWrappers::MPI::Vector>
     {
-      return [&matrix](TrilinosWrappers::MPI::Vector &v, bool fast)
+    public:
+      template <typename Matrix>
+      std::function<void(TrilinosWrappers::MPI::Vector &, bool)>
+      operator()(const Matrix &matrix)
       {
-        v.reinit(matrix.range_partitioner(), fast);
-      };
-    }
-  };
+        return [&matrix](TrilinosWrappers::MPI::Vector &v, bool fast)
+        {
+          v.reinit(matrix.range_partitioner(), fast);
+        };
+      }
+    };
 
-  /*
-   * A factory class internally used in linear_operator.h.
-   * Specialization for TrilinosWrappers::MPI::Vector.
-   */
-  template<>
-  class ReinitDomainFactory<TrilinosWrappers::MPI::Vector>
-  {
-  public:
-    template <typename Matrix>
-    std::function<void(TrilinosWrappers::MPI::Vector &, bool)>
-    operator()(const Matrix &matrix)
+    /**
+     * A factory class internally used in linear_operator.h. Specialization
+     * for TrilinosWrappers::MPI::Vector.
+     */
+    template<>
+    class ReinitDomainFactory<TrilinosWrappers::MPI::Vector>
     {
-      return [&matrix](TrilinosWrappers::MPI::Vector &v, bool fast)
+    public:
+      template <typename Matrix>
+      std::function<void(TrilinosWrappers::MPI::Vector &, bool)>
+      operator()(const Matrix &matrix)
       {
-        v.reinit(matrix.domain_partitioner(), fast);
-      };
-    }
-  };
+        return [&matrix](TrilinosWrappers::MPI::Vector &v, bool fast)
+        {
+          v.reinit(matrix.domain_partitioner(), fast);
+        };
+      }
+    };
 
-  /*
-   * A factory class internally used in linear_operator.h.
-   * Specialization for TrilinosWrappers::MPI::Vector.
-   */
-  template<>
-  class ReinitRangeFactory<TrilinosWrappers::Vector>
-  {
-  public:
-    template <typename Matrix>
-    std::function<void(TrilinosWrappers::Vector &, bool)>
-    operator()(const Matrix &matrix)
+    /**
+     * A factory class internally used in linear_operator.h. Specialization
+     * for TrilinosWrappers::MPI::Vector.
+     */
+    template<>
+    class ReinitRangeFactory<TrilinosWrappers::Vector>
     {
-      return [&matrix](TrilinosWrappers::Vector &v, bool fast)
+    public:
+      template <typename Matrix>
+      std::function<void(TrilinosWrappers::Vector &, bool)>
+      operator()(const Matrix &matrix)
       {
-        v.reinit(matrix.range_partitioner(), fast);
-      };
-    }
-  };
+        return [&matrix](TrilinosWrappers::Vector &v, bool fast)
+        {
+          v.reinit(matrix.range_partitioner(), fast);
+        };
+      }
+    };
 
-  /*
-   * A factory class internally used in linear_operator.h.
-   * Specialization for TrilinosWrappers::MPI::Vector.
-   */
-  template<>
-  class ReinitDomainFactory<TrilinosWrappers::Vector>
-  {
-  public:
-    template <typename Matrix>
-    std::function<void(TrilinosWrappers::Vector &, bool)>
-    operator()(const Matrix &matrix)
+    /**
+     * A factory class internally used in linear_operator.h. Specialization
+     * for TrilinosWrappers::MPI::Vector.
+     */
+    template<>
+    class ReinitDomainFactory<TrilinosWrappers::Vector>
     {
-      return [&matrix](TrilinosWrappers::Vector &v, bool fast)
+    public:
+      template <typename Matrix>
+      std::function<void(TrilinosWrappers::Vector &, bool)>
+      operator()(const Matrix &matrix)
       {
-        v.reinit(matrix.domain_partitioner(), fast);
-      };
-    }
-  };
+        return [&matrix](TrilinosWrappers::Vector &v, bool fast)
+        {
+          v.reinit(matrix.domain_partitioner(), fast);
+        };
+      }
+    };
+  } /* namespace LinearOperator */
 } /* namespace internal */