astyle on recent changes

git-svn-id: https://svn.dealii.org/trunk@32968 0785d39b-7218-0410-832d-ea1e28bc413d

diff --git a/deal.II/include/deal.II/algorithms/any_data.h b/deal.II/include/deal.II/algorithms/any_data.h
index f903bbe693371542994e7df4661079ddedcf1d06..9d67972c95e904e2bb3de876ae2923748de4ffd1 100644 (file)
--- a/deal.II/include/deal.II/algorithms/any_data.h
+++ b/deal.II/include/deal.II/algorithms/any_data.h
@@ -36,159 +36,159 @@ DEAL_II_NAMESPACE_OPEN
  * for long enough, then change to a map.
  */
 class AnyData :
-   public Subscriptor
+  public Subscriptor
 {
-  public:
-    /// Default constructor for empty object
-    AnyData();
-    
-    /// Number of stored data objects.
-    unsigned int size() const;
-    
-    /// Add a new data object
-    template <typename type>
-    void add(type entry, const std::string& name);
-  
-    /**
-     * @brief Merge the data of another NamedData to the end of this object.
-     */
-    void merge(const AnyData& other);
-
-    /**
-     * @brief Access to stored data object by name.
-     *
-     * Find the object with given name, try to convert it to
-     * <tt>type</tt> and return it. This function throws an exception
-     * if either the name does not exist or if the conversion
-     * fails. If such an exception is not desired, use try_read()
-     * instead.
-     */
-    template <typename type>
-    type entry (const std::string& name);
-
-    /**
-     * @brief Read-only access to stored data object by name.
-     *
-     * Find the object with given name, try to convert it to
-     * <tt>type</tt> and return it. This function throws an exception
-     * if either the name does not exist or if the conversion
-     * fails. If such an exception is not desired, use try_read()
-     * instead.
-     */
-    template <typename type>
-    const type entry (const std::string& name) const;
-
-    /**
-     * @brief Dedicated read only access by name.
-     *
-     * For a constant object, this function equals entry(). For a
-     * non-const object, it forces read only access to the data. In
-     * particular, it throws an exception if the object is not found
-     * or cannot be converted to type.  If such an exception is not
-     * desired, use try_read() instead.
-     *
-     * @warning Do not use this function for stored objects which are
-     * pointers. Use read_ptr() instead!
-     */
-    template <typename type>
-    const type read (const std::string& name) const;
-    
-    /**
-     * @brief Dedicated read only access by name for pointer data.
-     *
-     * If the stored data object is a pointer to a constant object, the logic
-     * of access becomes fairly complicated. Namely, the standard read
-     * function may fail, depending on whether it was a const pointer
-     * or a regular pointer. This function fixes the logic and
-     * ascertains that the object does not become mutable by accident.
-     */
-    template <typename type>
-    const type* read_ptr (const std::string& name) const;
-
-    /**
-     * Perform the same action as read_ptr(), but do not throw an
-     * exception if the pointer does not exist. Return a null pointer
-     * instead.
-     */
-    template <typename type>
-    const type* try_read_ptr (const std::string& name) const;
-    
-    /**
-     * @brief Dedicated read only access by name without exceptions.
-     *
-     * This function tries to find the name in the list and return a
-     * pointer to the associated object. If either the name is not
-     * found or the object cannot be converted to the return type, a
-     * null pointer is returned.
-     */
-    template <typename type>
-    const type * try_read (const std::string& name) const;
-    
+public:
+  /// Default constructor for empty object
+  AnyData();
+
+  /// Number of stored data objects.
+  unsigned int size() const;
+
+  /// Add a new data object
+  template <typename type>
+  void add(type entry, const std::string &name);
+
+  /**
+   * @brief Merge the data of another NamedData to the end of this object.
+   */
+  void merge(const AnyData &other);
+
+  /**
+   * @brief Access to stored data object by name.
+   *
+   * Find the object with given name, try to convert it to
+   * <tt>type</tt> and return it. This function throws an exception
+   * if either the name does not exist or if the conversion
+   * fails. If such an exception is not desired, use try_read()
+   * instead.
+   */
+  template <typename type>
+  type entry (const std::string &name);
+
+  /**
+   * @brief Read-only access to stored data object by name.
+   *
+   * Find the object with given name, try to convert it to
+   * <tt>type</tt> and return it. This function throws an exception
+   * if either the name does not exist or if the conversion
+   * fails. If such an exception is not desired, use try_read()
+   * instead.
+   */
+  template <typename type>
+  const type entry (const std::string &name) const;
+
+  /**
+   * @brief Dedicated read only access by name.
+   *
+   * For a constant object, this function equals entry(). For a
+   * non-const object, it forces read only access to the data. In
+   * particular, it throws an exception if the object is not found
+   * or cannot be converted to type.  If such an exception is not
+   * desired, use try_read() instead.
+   *
+   * @warning Do not use this function for stored objects which are
+   * pointers. Use read_ptr() instead!
+   */
+  template <typename type>
+  const type read (const std::string &name) const;
+
+  /**
+   * @brief Dedicated read only access by name for pointer data.
+   *
+   * If the stored data object is a pointer to a constant object, the logic
+   * of access becomes fairly complicated. Namely, the standard read
+   * function may fail, depending on whether it was a const pointer
+   * or a regular pointer. This function fixes the logic and
+   * ascertains that the object does not become mutable by accident.
+   */
+  template <typename type>
+  const type *read_ptr (const std::string &name) const;
+
+  /**
+   * Perform the same action as read_ptr(), but do not throw an
+   * exception if the pointer does not exist. Return a null pointer
+   * instead.
+   */
+  template <typename type>
+  const type *try_read_ptr (const std::string &name) const;
+
+  /**
+   * @brief Dedicated read only access by name without exceptions.
+   *
+   * This function tries to find the name in the list and return a
+   * pointer to the associated object. If either the name is not
+   * found or the object cannot be converted to the return type, a
+   * null pointer is returned.
+   */
+  template <typename type>
+  const type *try_read (const std::string &name) const;
+
   /**
    * Access to stored data object by index.
    */
-    template <typename type>
-    type entry (const unsigned int i);
-
-    /// Read-only access to stored data object by index.
-    template <typename type>
-    const type entry (const unsigned int i) const;
-
-    /// Dedicated read only access.
-    template <typename type>
-    const type read (const unsigned int i) const;
-
-    /// Dedicated read only access to pointer object.
-    template <typename type>
-    const type* read_ptr (const unsigned int i) const;
-
-    /// Dedicated read only access to pointer object without exception.
-    template <typename type>
-    const type* try_read_ptr (const unsigned int i) const;
-
-    /// Dedicated read only access without exception.
-    template <typename type>
-    const type* try_read (const unsigned int i) const;
-    
-    /// Name of object at index.
-    const std::string &name(const unsigned int i) const;
-
-    /**
-     * @brief Find index of a named object
-     *
-     * Try to find the objecty and return its index in the list. Throw
-     * an exception if the object has not been found.
-     */
-    unsigned int find(const std::string &name) const;
-
-    /**
-     * @brief Try to find index of a named object
-     *
-     * Try to find the objecty and return its index in the
-     * list. returns numbers::invalid_unsigned_int if the name was not
-     * found.
-     */
-    unsigned int try_find(const std::string &name) const;
-
-    /// Find out if object is of a certain type
-    template <typename type>
-    bool is_type(const unsigned int i) const;
-
-    /// Conversion from old NamedData
-    template <typename type>
-    AnyData(const NamedData<type>&);
-
-    /// An entry with this name does not exist in the AnyData object.
-    DeclException1(ExcNameNotFound, std::string&,
-                  << "No entry with the name " << arg1 << " exists");
-    
-    /// The requested type and the stored type are different
-    DeclException2(ExcTypeMismatch,
-                  char*, char*,
-                  << "The requested type " << arg1
-                  << " and the stored type " << arg2
-                  << " must coincide");
-  
+  template <typename type>
+  type entry (const unsigned int i);
+
+  /// Read-only access to stored data object by index.
+  template <typename type>
+  const type entry (const unsigned int i) const;
+
+  /// Dedicated read only access.
+  template <typename type>
+  const type read (const unsigned int i) const;
+
+  /// Dedicated read only access to pointer object.
+  template <typename type>
+  const type *read_ptr (const unsigned int i) const;
+
+  /// Dedicated read only access to pointer object without exception.
+  template <typename type>
+  const type *try_read_ptr (const unsigned int i) const;
+
+  /// Dedicated read only access without exception.
+  template <typename type>
+  const type *try_read (const unsigned int i) const;
+
+  /// Name of object at index.
+  const std::string &name(const unsigned int i) const;
+
+  /**
+   * @brief Find index of a named object
+   *
+   * Try to find the objecty and return its index in the list. Throw
+   * an exception if the object has not been found.
+   */
+  unsigned int find(const std::string &name) const;
+
+  /**
+   * @brief Try to find index of a named object
+   *
+   * Try to find the objecty and return its index in the
+   * list. returns numbers::invalid_unsigned_int if the name was not
+   * found.
+   */
+  unsigned int try_find(const std::string &name) const;
+
+  /// Find out if object is of a certain type
+  template <typename type>
+  bool is_type(const unsigned int i) const;
+
+  /// Conversion from old NamedData
+  template <typename type>
+  AnyData(const NamedData<type> &);
+
+  /// An entry with this name does not exist in the AnyData object.
+  DeclException1(ExcNameNotFound, std::string &,
+                 << "No entry with the name " << arg1 << " exists");
+
+  /// The requested type and the stored type are different
+  DeclException2(ExcTypeMismatch,
+                 char *, char *,
+                 << "The requested type " << arg1
+                 << " and the stored type " << arg2
+                 << " must coincide");
+
   /**
    * Exception indicating that a function expected a vector to have a
    * certain name, but NamedData had a different name in that
@@ -196,11 +196,11 @@ class AnyData :
    */
   DeclException2(ExcNameMismatch, int, std::string,
                  << "Name at position " << arg1 << " is not equal to " << arg2);
-  private:
-    /// The stored data
-    std::vector<boost::any> data;
-    /// The names of the stored data
-    std::vector<std::string> names;
+private:
+  /// The stored data
+  std::vector<boost::any> data;
+  /// The names of the stored data
+  std::vector<std::string> names;
 };
 
 
@@ -211,9 +211,9 @@ AnyData::AnyData()
 
 template <typename type>
 inline
-AnyData::AnyData(const NamedData<type>& other)
+AnyData::AnyData(const NamedData<type> &other)
 {
-  for (unsigned int i=0;i<other.size();++i)
+  for (unsigned int i=0; i<other.size(); ++i)
     add(other(i), other.name(i));
 }
 
@@ -233,9 +233,9 @@ type
 AnyData::entry (const unsigned int i)
 {
   AssertIndexRange(i, size());
-  type* p = boost::any_cast<type>(&data[i]);
+  type *p = boost::any_cast<type>(&data[i]);
   Assert(p != 0,
-        ExcTypeMismatch(typeid(type).name(),data[i].type().name()));
+         ExcTypeMismatch(typeid(type).name(),data[i].type().name()));
   return *p;
 }
 
@@ -246,11 +246,11 @@ const type
 AnyData::entry (const unsigned int i) const
 {
   AssertIndexRange(i, size());
-  const type* p = boost::any_cast<type>(&data[i]);
+  const type *p = boost::any_cast<type>(&data[i]);
   if (p==0 )
     p = boost::any_cast<const type>(&data[i]);
   Assert(p != 0,
-        ExcTypeMismatch(typeid(type).name(),data[i].type().name()));
+         ExcTypeMismatch(typeid(type).name(),data[i].type().name()));
   return *p;
 }
 
@@ -261,50 +261,50 @@ const type
 AnyData::read(const unsigned int i) const
 {
   AssertIndexRange(i, size());
-  const type* p = boost::any_cast<type>(&data[i]);
+  const type *p = boost::any_cast<type>(&data[i]);
   if (p==0)
     p = boost::any_cast<const type>(&data[i]);
   Assert(p != 0,
-        ExcTypeMismatch(typeid(type).name(),data[i].type().name()));
+         ExcTypeMismatch(typeid(type).name(),data[i].type().name()));
   return *p;
 }
 
 
 template <typename type>
 inline
-const type*
+const type *
 AnyData::read_ptr(const unsigned int i) const
 {
   AssertIndexRange(i, size());
-  const type* const * p = boost::any_cast<type*>(&data[i]);
+  const type *const *p = boost::any_cast<type *>(&data[i]);
   if (p==0)
-    p = boost::any_cast<const type*>(&data[i]);
+    p = boost::any_cast<const type *>(&data[i]);
   Assert(p != 0,
-        ExcTypeMismatch(typeid(type*).name(),data[i].type().name()));
+         ExcTypeMismatch(typeid(type *).name(),data[i].type().name()));
   return *p;
 }
 
 
 template <typename type>
 inline
-const type*
+const type *
 AnyData::try_read_ptr(const unsigned int i) const
 {
   AssertIndexRange(i, size());
-  const type* const * p = boost::any_cast<type*>(&data[i]);
+  const type *const *p = boost::any_cast<type *>(&data[i]);
   if (p==0)
-    p = boost::any_cast<const type*>(&data[i]);
+    p = boost::any_cast<const type *>(&data[i]);
   return *p;
 }
 
 
 template <typename type>
 inline
-const type*
+const type *
 AnyData::try_read(const unsigned int i) const
 {
   AssertIndexRange(i, size());
-  const type* p = boost::any_cast<type>(&data[i]);
+  const type *p = boost::any_cast<type>(&data[i]);
   if (p==0)
     p = boost::any_cast<const type>(&data[i]);
   return p;
@@ -312,7 +312,7 @@ AnyData::try_read(const unsigned int i) const
 
 
 inline
-const std::string&
+const std::string &
 AnyData::name(const unsigned int i) const
 {
   AssertIndexRange(i, size());
@@ -322,25 +322,25 @@ AnyData::name(const unsigned int i) const
 
 inline
 unsigned int
-AnyData::try_find(const std::string& n) const
+AnyData::try_find(const std::string &n) const
 {
   std::vector<std::string>::const_iterator it =
     std::find(names.begin(), names.end(), n);
-  
+
   if (it == names.end())
     return numbers::invalid_unsigned_int;
-  
+
   return it - names.begin();
 }
 
 
 inline
 unsigned int
-AnyData::find(const std::string& n) const
+AnyData::find(const std::string &n) const
 {
   const unsigned int i = try_find(n);
   Assert(i != numbers::invalid_unsigned_int, ExcNameNotFound(n));
-  
+
   return i;
 }
 
@@ -357,12 +357,12 @@ AnyData::is_type(const unsigned int i) const
 template <typename type>
 inline
 type
-AnyData::entry (const std::string& n)
+AnyData::entry (const std::string &n)
 {
   const unsigned int i = find(n);
-  type* p = boost::any_cast<type>(&data[i]);
+  type *p = boost::any_cast<type>(&data[i]);
   Assert(p != 0,
-        ExcTypeMismatch(typeid(type).name(),data[i].type().name()));
+         ExcTypeMismatch(typeid(type).name(),data[i].type().name()));
   return *p;
 }
 
@@ -370,12 +370,12 @@ AnyData::entry (const std::string& n)
 template <typename type>
 inline
 const type
-AnyData::entry (const std::string& n) const
+AnyData::entry (const std::string &n) const
 {
   const unsigned int i = find(n);
-  const type* p = boost::any_cast<type>(&data[i]);
+  const type *p = boost::any_cast<type>(&data[i]);
   Assert(p != 0,
-        ExcTypeMismatch(typeid(type).name(),data[i].type().name()));
+         ExcTypeMismatch(typeid(type).name(),data[i].type().name()));
   return *p;
 }
 
@@ -383,51 +383,51 @@ AnyData::entry (const std::string& n) const
 template <typename type>
 inline
 const type
-AnyData::read(const std::string& n) const
+AnyData::read(const std::string &n) const
 {
   const unsigned int i = find(n);
-  const type* p = boost::any_cast<type>(&data[i]);
+  const type *p = boost::any_cast<type>(&data[i]);
   Assert(p != 0,
-        ExcTypeMismatch(typeid(type).name(),data[i].type().name()));
+         ExcTypeMismatch(typeid(type).name(),data[i].type().name()));
   return *p;
 }
 
 
 template <typename type>
 inline
-const type*
-AnyData::read_ptr(const std::string& n) const
+const type *
+AnyData::read_ptr(const std::string &n) const
 {
   const unsigned int i = find(n);
-  const type* const * p = boost::any_cast<type*>(&data[i]);
+  const type *const *p = boost::any_cast<type *>(&data[i]);
   if (p==0)
-    p = boost::any_cast<const type*>(&data[i]);
+    p = boost::any_cast<const type *>(&data[i]);
   Assert(p != 0,
-        ExcTypeMismatch(typeid(type).name(),data[i].type().name()));
+         ExcTypeMismatch(typeid(type).name(),data[i].type().name()));
   return *p;
 }
 
 
 template <typename type>
 inline
-const type*
-AnyData::try_read_ptr(const std::string& n) const
+const type *
+AnyData::try_read_ptr(const std::string &n) const
 {
   const unsigned int i = try_find(n);
   if (i == numbers::invalid_unsigned_int)
     return 0;
-  
-  const type* const * p = boost::any_cast<type*>(&data[i]);
+
+  const type *const *p = boost::any_cast<type *>(&data[i]);
   if (p==0)
-    p = boost::any_cast<const type*>(&data[i]);
+    p = boost::any_cast<const type *>(&data[i]);
   return *p;
 }
 
 
 template <typename type>
 inline
-const type*
-AnyData::try_read(const std::string& n) const
+const type *
+AnyData::try_read(const std::string &n) const
 {
   // Try to find name
   std::vector<std::string>::const_iterator it =
@@ -438,7 +438,7 @@ AnyData::try_read(const std::string& n) const
 
   // Compute index and return casted pointer
   unsigned int i=it-names.begin();
-  const type* p = boost::any_cast<type>(&data[i]);
+  const type *p = boost::any_cast<type>(&data[i]);
   return p;
 }
 
@@ -446,7 +446,7 @@ AnyData::try_read(const std::string& n) const
 template <typename type>
 inline
 void
-AnyData::add(type ent, const std::string& n)
+AnyData::add(type ent, const std::string &n)
 {
   boost::any e = ent;
   data.push_back(e);
@@ -456,7 +456,7 @@ AnyData::add(type ent, const std::string& n)
 
 inline
 void
-AnyData::merge(const AnyData& other)
+AnyData::merge(const AnyData &other)
 {
   for (unsigned int i=0; i<other.size(); ++i)
     {

diff --git a/deal.II/include/deal.II/algorithms/newton.h b/deal.II/include/deal.II/algorithms/newton.h
index 97ac90b4db228f9dcfcd76715f5f0b4697b759b7..c3bc9f4b9db772ae3cd050a0a0a9d9c6426d31dc 100644 (file)
--- a/deal.II/include/deal.II/algorithms/newton.h
+++ b/deal.II/include/deal.II/algorithms/newton.h
@@ -111,7 +111,7 @@ namespace Algorithms
     /**
      * @deprecated Use the function using AnyData
      */
-    virtual void operator() (NamedData<VECTOR*> &out, const NamedData<VECTOR*> &in);
+    virtual void operator() (NamedData<VECTOR *> &out, const NamedData<VECTOR *> &in);
 
     virtual void notify(const Event &);
 

diff --git a/deal.II/include/deal.II/algorithms/newton.templates.h b/deal.II/include/deal.II/algorithms/newton.templates.h
index acb61f4712c1c43a719eb231a2a568bd0381c7ba..c397fd22beb065965257a396ae2266a96db8a268 100644 (file)
--- a/deal.II/include/deal.II/algorithms/newton.templates.h
+++ b/deal.II/include/deal.II/algorithms/newton.templates.h
@@ -80,7 +80,7 @@ namespace Algorithms
     inverse_derivative->notify(e);
   }
 
-  
+
   template <class VECTOR>
   double
   Newton<VECTOR>::threshold(const double thr)
@@ -89,8 +89,8 @@ namespace Algorithms
     assemble_threshold = thr;
     return t;
   }
-  
-  
+
+
   template <class VECTOR>
   void
   Newton<VECTOR>::operator() (NamedData<VECTOR *> &out, const NamedData<VECTOR *> &in)
@@ -105,7 +105,7 @@ namespace Algorithms
     Assert (out.size() == 1, ExcNotImplemented());
     deallog.push ("Newton");
 
-    VECTOR &u = *out.entry<VECTOR*>(0);
+    VECTOR &u = *out.entry<VECTOR *>(0);
 
     if (debug>2)
       deallog << "u: " << u.l2_norm() << std::endl;
@@ -117,14 +117,14 @@ namespace Algorithms
     res->reinit(u);
     AnyData src1;
     AnyData src2;
-    src1.add<const VECTOR*>(&u, "Newton iterate");
+    src1.add<const VECTOR *>(&u, "Newton iterate");
     src1.merge(in);
-    src2.add<const VECTOR*>(res, "Newton residual");
+    src2.add<const VECTOR *>(res, "Newton residual");
     src2.merge(src1);
     AnyData out1;
-    out1.add<VECTOR*>(res, "Residual");
+    out1.add<VECTOR *>(res, "Residual");
     AnyData out2;
-    out2.add<VECTOR*>(Du, "Update");
+    out2.add<VECTOR *>(Du, "Update");
 
     unsigned int step = 0;
     // fill res with (f(u), v)

diff --git a/deal.II/include/deal.II/algorithms/operator.h b/deal.II/include/deal.II/algorithms/operator.h
index bad83a96dd6554ab5f6b4cbdc58e0d734b8cac23..2f5e935127fd5b0fc77addb1279338939b68038f 100644 (file)
--- a/deal.II/include/deal.II/algorithms/operator.h
+++ b/deal.II/include/deal.II/algorithms/operator.h
@@ -103,7 +103,7 @@ namespace Algorithms
      * of reassembling the matrix.
      */
     Event notifications;
-    
+
   };
 
   /**
@@ -141,7 +141,7 @@ namespace Algorithms
   {
   public:
     Operator();
-    
+
     /**
      * Implementation of the function in the base class in order to do
      * compatibility conversions between the old and the new
@@ -161,7 +161,7 @@ namespace Algorithms
      * Set this true to avoid compatibility warnings.
      */
     bool silent_compatibility;
-      
+
   private:
     /**
      * While we are providing compatibility functions to the old
@@ -203,8 +203,8 @@ namespace Algorithms
     /**
      * Output all the vectors in AnyData.
      */
-    virtual OutputOperator<VECTOR> &operator<< (const AnyData& vectors);
-    
+    virtual OutputOperator<VECTOR> &operator<< (const AnyData &vectors);
+
     /**
      * @deprecated Output all the vectors in NamedData.
      */

diff --git a/deal.II/include/deal.II/algorithms/operator.templates.h b/deal.II/include/deal.II/algorithms/operator.templates.h
index 0a941933ed22c6ea269fce644094113b8c863c4c..0824616807ac2d47232fd20fbbdca3b739f1d60f 100644 (file)
--- a/deal.II/include/deal.II/algorithms/operator.templates.h
+++ b/deal.II/include/deal.II/algorithms/operator.templates.h
@@ -24,58 +24,56 @@ namespace Algorithms
 {
   template <class VECTOR>
   Operator<VECTOR>::Operator()
-                 : silent_compatibility(false), compatibility_flag(false)
+    : silent_compatibility(false), compatibility_flag(false)
   {}
 
 
   template <class VECTOR>
   void
-  Operator<VECTOR>::operator() (AnyData& out, const AnyData& in)
+  Operator<VECTOR>::operator() (AnyData &out, const AnyData &in)
   {
     // Had this function been overloaded in a derived clas, it would
     // not have been called. Therefore, we have to start the
     // compatibility engine. But before, we have to avoid an endless loop.
     Assert(!compatibility_flag, ExcMessage("Compatibility resolution of Operator generates and endless loop\n"
-                                          "Please provide an operator() in a derived class"));
+                                           "Please provide an operator() in a derived class"));
     compatibility_flag = true;
-    
-    NamedData<VECTOR*> new_out;
-    for (unsigned int i=0;i<out.size();++i)
+
+    NamedData<VECTOR *> new_out;
+    for (unsigned int i=0; i<out.size(); ++i)
       {
-       if (out.is_type<VECTOR*>(i))
-         new_out.add(out.entry<VECTOR*>(i), out.name(i));
-       else
-         if (!silent_compatibility)
-           deallog << "Cannot convert AnyData argument " << out.name(i) << " to NamedData"
-                   << std::endl;
+        if (out.is_type<VECTOR *>(i))
+          new_out.add(out.entry<VECTOR *>(i), out.name(i));
+        else if (!silent_compatibility)
+          deallog << "Cannot convert AnyData argument " << out.name(i) << " to NamedData"
+                  << std::endl;
       }
-    
-    NamedData<VECTOR*> new_in;
-    for (unsigned int i=0;i<in.size();++i)
+
+    NamedData<VECTOR *> new_in;
+    for (unsigned int i=0; i<in.size(); ++i)
       {
-       //      deallog << "Convert " << in.name(i) << std::endl;
-       if (in.is_type<VECTOR*>(i))
-         {
-           // This const cast is due to the wrong constness handling
-           // in NamedData. As soon as NamedData is gone, this code
-           // will not be necessary anymore. And deprecating begins
-           // now.
-           VECTOR* p = const_cast<VECTOR*> (in.entry<VECTOR*>(i));
-           new_in.add(p, in.name(i));
-         }
-       else if (in.is_type<const VECTOR*>(i))
-         {
-           // This const cast is due to the wrong constness handling
-           // in NamedData. As soon as NamedData is gone, this code
-           // will not be necessary anymore. And deprecating begins
-           // now.
-           VECTOR* p = const_cast<VECTOR*> (in.entry<const VECTOR*>(i));
-           new_in.add(p, in.name(i));
-         }
-       else
-         if (!silent_compatibility)
-           deallog << "Cannot convert AnyData argument " << in.name(i)
-                   << " to NamedData" << std::endl;
+        //  deallog << "Convert " << in.name(i) << std::endl;
+        if (in.is_type<VECTOR *>(i))
+          {
+            // This const cast is due to the wrong constness handling
+            // in NamedData. As soon as NamedData is gone, this code
+            // will not be necessary anymore. And deprecating begins
+            // now.
+            VECTOR *p = const_cast<VECTOR *> (in.entry<VECTOR *>(i));
+            new_in.add(p, in.name(i));
+          }
+        else if (in.is_type<const VECTOR *>(i))
+          {
+            // This const cast is due to the wrong constness handling
+            // in NamedData. As soon as NamedData is gone, this code
+            // will not be necessary anymore. And deprecating begins
+            // now.
+            VECTOR *p = const_cast<VECTOR *> (in.entry<const VECTOR *>(i));
+            new_in.add(p, in.name(i));
+          }
+        else if (!silent_compatibility)
+          deallog << "Cannot convert AnyData argument " << in.name(i)
+                  << " to NamedData" << std::endl;
       }
     this->operator() (new_out, new_in);
     compatibility_flag = false;
@@ -84,21 +82,21 @@ namespace Algorithms
 
   template <class VECTOR>
   void
-  Operator<VECTOR>::operator() (NamedData<VECTOR*>& out, const NamedData<VECTOR*>& in)
+  Operator<VECTOR>::operator() (NamedData<VECTOR *> &out, const NamedData<VECTOR *> &in)
   {
     // Had this function been overloaded in a derived clas, it would
     // not have been called. Therefore, we have to start the
     // compatibility engine. But before, we have to avoid an endless loop.
     Assert(!compatibility_flag, ExcMessage("Compatibility resolution of Operator generates and endless loop\n"
-                                          "Please provide an operator() in a derived class"));
+                                           "Please provide an operator() in a derived class"));
     compatibility_flag = true;
-    
+
     AnyData new_out;
-    for (unsigned int i=0;i<out.size();++i)
+    for (unsigned int i=0; i<out.size(); ++i)
       new_out.add(out(i), out.name(i));
 
     AnyData new_in;
-    for (unsigned int i=0;i<in.size();++i)
+    for (unsigned int i=0; i<in.size(); ++i)
       new_in.add(in(i), in.name(i));
 
     this->operator() (new_out, new_in);
@@ -124,37 +122,37 @@ namespace Algorithms
 
   template <class VECTOR>
   OutputOperator<VECTOR> &
-  OutputOperator<VECTOR>::operator<< (const AnyData& vectors)
+  OutputOperator<VECTOR>::operator<< (const AnyData &vectors)
   {
     if (os == 0)
       {
         deallog << "Step " << step << std::endl;
         for (unsigned int i=0; i<vectors.size(); ++i)
-         {
-           const VECTOR* v = vectors.try_read_ptr<VECTOR>(i);
-           if (v == 0) continue;
-           for (unsigned int j=0; j<v->size(); ++j)
-             (*os) << ' ' << (*v)(j);
-           deallog << std::endl;
-         }
+          {
+            const VECTOR *v = vectors.try_read_ptr<VECTOR>(i);
+            if (v == 0) continue;
+            for (unsigned int j=0; j<v->size(); ++j)
+              (*os) << ' ' << (*v)(j);
+            deallog << std::endl;
+          }
         deallog << std::endl;
       }
     else
       {
         (*os) << ' ' << step;
         for (unsigned int i=0; i<vectors.size(); ++i)
-         {
-           const VECTOR* v = vectors.try_read_ptr<VECTOR>(i);
-           if (v == 0) continue;
-           for (unsigned int j=0; j<v->size(); ++j)
-             (*os) << ' ' << (*v)(j);
-           (*os) << std::endl;
-         }
+          {
+            const VECTOR *v = vectors.try_read_ptr<VECTOR>(i);
+            if (v == 0) continue;
+            for (unsigned int j=0; j<v->size(); ++j)
+              (*os) << ' ' << (*v)(j);
+            (*os) << std::endl;
+          }
         (*os) << std::endl;
       }
     return *this;
   }
-  
+
 
   template <class VECTOR>
   OutputOperator<VECTOR> &

diff --git a/deal.II/include/deal.II/algorithms/theta_timestepping.templates.h b/deal.II/include/deal.II/algorithms/theta_timestepping.templates.h
index ab0d36a24368935a179e79b4edcbb0da07c37f66..3e3e19c765ca38004706d7b5a8a1ddb3f0a6055d 100644 (file)
--- a/deal.II/include/deal.II/algorithms/theta_timestepping.templates.h
+++ b/deal.II/include/deal.II/algorithms/theta_timestepping.templates.h
@@ -67,8 +67,8 @@ namespace Algorithms
   {
     Operator<VECTOR>::operator() (out, in);
   }
-  
-  
+
+
   template <class VECTOR>
   void
   ThetaTimestepping<VECTOR>::operator() (AnyData &out, const AnyData &in)
@@ -77,7 +77,7 @@ namespace Algorithms
 
     deallog.push ("Theta");
 
-    VECTOR& solution = *out.entry<VECTOR*>(0);
+    VECTOR &solution = *out.entry<VECTOR *>(0);
     GrowingVectorMemory<VECTOR> mem;
     typename VectorMemory<VECTOR>::Pointer aux(mem);
     aux->reinit(solution);
@@ -90,20 +90,20 @@ namespace Algorithms
     // vector associated with the old
     // timestep
     AnyData src1;
-    src1.add<const VECTOR*>(&solution, "Previous iterate");
-    src1.add<const double*>(&d_explicit.time, "Time");
-    src1.add<const double*>(&d_explicit.step, "Timestep");
+    src1.add<const VECTOR *>(&solution, "Previous iterate");
+    src1.add<const double *>(&d_explicit.time, "Time");
+    src1.add<const double *>(&d_explicit.step, "Timestep");
     src1.merge(in);
 
     AnyData src2;
-    src2.add<const VECTOR*>(&solution, "Previous iterate");
+    src2.add<const VECTOR *>(&solution, "Previous iterate");
 
     AnyData out1;
-    out1.add<VECTOR*>(aux, "Solution");
+    out1.add<VECTOR *>(aux, "Solution");
     // The data provided to the inner solver
-    src2.add<const VECTOR*>(aux, "Previous time");
-    src2.add<const double*>(&d_implicit.time, "Time");
-    src2.add<const double*>(&d_explicit.step, "Timestep");
+    src2.add<const VECTOR *>(aux, "Previous time");
+    src2.add<const double *>(&d_implicit.time, "Time");
+    src2.add<const double *>(&d_explicit.step, "Timestep");
     src2.merge(in);
 
     if (output != 0)
@@ -114,7 +114,7 @@ namespace Algorithms
     const bool implicit_silent = op_implicit->silent_compatibility;
     op_explicit->silent_compatibility = true;
     op_implicit->silent_compatibility = true;
-    
+
     for (unsigned int count = 1; d_explicit.time < control.final(); ++count)
       {
         const bool step_change = control.advance();