Merge pull request #6746 from bangerth/plugin-serialize

Push down the functionality to serialize plugins to the InterfaceBase level.

Author: gassmoeller

include/aspect/mesh_deformation/interface.h

@@ -119,45 +119,6 @@ namespace aspect
         compute_velocity_constraints_on_boundary(const DoFHandler<dim> &mesh_deformation_dof_handler,
                                                  AffineConstraints<double> &mesh_velocity_constraints,
                                                  const std::set<types::boundary_id> &boundary_ids) const;
-
-
-        /**
-         * Save the state of this object to the argument given to this
-         * function. This function is in support of checkpoint/restart
-         * functionality.
-         *
-         * Derived classes can implement this function and should store their
-         * state in a string that is deposited under a key in the map through
-         * which the respective class can later find the status again when the
-         * program is restarted. A legitimate key to store data under is
-         * <code>typeid(*this).name()</code>. It is up to derived classes to
-         * decide how they want to encode their state.
-         *
-         * The default implementation of this function does nothing, i.e., it
-         * represents a stateless object for which nothing needs to be stored
-         * at checkpoint time and nothing needs to be restored at restart
-         * time.
-         *
-         * @param[in,out] status_strings The object into which implementations
-         * in derived classes can place their status under a key that they can
-         * use to retrieve the data.
-         */
-        virtual
-        void save (std::map<std::string, std::string> &status_strings) const;
-
-        /**
-         * Restore the state of the object by looking up a description of the
-         * state in the passed argument under the same key under which it was
-         * previously stored.
-         *
-         * The default implementation does nothing.
-         *
-         * @param[in] status_strings The object from which the status will be
-         * restored by looking up the value for a key specific to this derived
-         * class.
-         */
-        virtual
-        void load (const std::map<std::string, std::string> &status_strings);
     };
 
 

include/aspect/plugins.h

@@ -184,6 +184,44 @@ namespace aspect
         virtual
         void
         parse_parameters (ParameterHandler &prm);
+
+        /**
+         * Save the state of this object to the argument given to this
+         * function. This function is in support of checkpoint/restart
+         * functionality.
+         *
+         * Derived classes can implement this function and should store their
+         * state in a string that is deposited under a key in the map through
+         * which the respective class can later find the status again when the
+         * program is restarted. A legitimate key to store data under is
+         * <code>typeid(*this).name()</code>. It is up to derived classes to
+         * decide how they want to encode their state.
+         *
+         * The default implementation of this function does nothing, i.e., it
+         * represents a stateless object for which nothing needs to be stored
+         * at checkpoint time and nothing needs to be restored at restart
+         * time.
+         *
+         * @param[in,out] status_strings The object into which implementations
+         * in derived classes can place their status under a key that they can
+         * use to retrieve the data.
+         */
+        virtual
+        void save (std::map<std::string, std::string> &status_strings) const;
+
+        /**
+         * Restore the state of the object by looking up a description of the
+         * state in the passed argument under the same key under which it was
+         * previously stored.
+         *
+         * The default implementation does nothing.
+         *
+         * @param[in] status_strings The object from which the status will be
+         * restored by looking up the value for a key specific to this derived
+         * class.
+         */
+        virtual
+        void load (const std::map<std::string, std::string> &status_strings);
     };
 
 
@@ -281,13 +319,29 @@ namespace aspect
                    const unsigned int version) const;
 
         /**
-         * Read the data of this object from a stream for the purpose of
-         * serialization.
+         * Manager classes are also plugins. The InterfaceBase class
+         * that is common to all plugins has another save() function
+         * that would be hidden by the one above. Make sure that both
+         * remain visible.
          */
+        using InterfaceBase::save;
+
+        /**
+           * Read the data of this object from a stream for the purpose of
+           * serialization.
+           */
         template <class Archive>
         void load (Archive &ar,
                    const unsigned int version);
 
+        /**
+         * Manager classes are also plugins. The InterfaceBase class
+         * that is common to all plugins has another load() function
+         * that would be hidden by the one above. Make sure that both
+         * remain visible.
+         */
+        using InterfaceBase::load;
+
         BOOST_SERIALIZATION_SPLIT_MEMBER()
 
       protected:

include/aspect/postprocess/interface.h

@@ -115,51 +115,10 @@ namespace aspect
         virtual
         std::list<std::string>
         required_other_postprocessors () const;
-
-        /**
-         * Save the state of this object to the argument given to this
-         * function. This function is in support of checkpoint/restart
-         * functionality.
-         *
-         * Derived classes can implement this function and should store their
-         * state in a string that is deposited under a key in the map through
-         * which the respective class can later find the status again when the
-         * program is restarted. A legitimate key to store data under is
-         * <code>typeid(*this).name()</code>. It is up to derived classes to
-         * decide how they want to encode their state.
-         *
-         * The default implementation of this function does nothing, i.e., it
-         * represents a stateless object for which nothing needs to be stored
-         * at checkpoint time and nothing needs to be restored at restart
-         * time.
-         *
-         * @param[in,out] status_strings The object into which implementations
-         * in derived classes can place their status under a key that they can
-         * use to retrieve the data.
-         */
-        virtual
-        void save (std::map<std::string, std::string> &status_strings) const;
-
-        /**
-         * Restore the state of the object by looking up a description of the
-         * state in the passed argument under the same key under which it was
-         * previously stored.
-         *
-         * The default implementation does nothing.
-         *
-         * @param[in] status_strings The object from which the status will be
-         * restored by looking up the value for a key specific to this derived
-         * class.
-         */
-        virtual
-        void load (const std::map<std::string, std::string> &status_strings);
     };
 
 
 
-
-
-
     /**
      * A class that manages all objects that provide functionality to
      * postprocess solutions. It declares run time parameters for input files,

include/aspect/postprocess/visualization.h

@@ -178,44 +178,6 @@ namespace aspect
           std::list<std::string>
           required_other_postprocessors () const;
 
-          /**
-           * Save the state of this object to the argument given to this
-           * function. This function is in support of checkpoint/restart
-           * functionality.
-           *
-           * Derived classes can implement this function and should store
-           * their state in a string that is deposited under a key in the map
-           * through which the respective class can later find the status
-           * again when the program is restarted. A legitimate key to store
-           * data under is <code>typeid(*this).name()</code>. It is up to
-           * derived classes to decide how they want to encode their state.
-           *
-           * The default implementation of this function does nothing, i.e.,
-           * it represents a stateless object for which nothing needs to be
-           * stored at checkpoint time and nothing needs to be restored at
-           * restart time.
-           *
-           * @param[in,out] status_strings The object into which
-           * implementations in derived classes can place their status under a
-           * key that they can use to retrieve the data.
-           */
-          virtual
-          void save (std::map<std::string, std::string> &status_strings) const;
-
-          /**
-           * Restore the state of the object by looking up a description of
-           * the state in the passed argument under the same key under which
-           * it was previously stored.
-           *
-           * The default implementation does nothing.
-           *
-           * @param[in] status_strings The object from which the status will
-           * be restored by looking up the value for a key specific to this
-           * derived class.
-           */
-          virtual
-          void load (const std::map<std::string, std::string> &status_strings);
-
         private:
           /**
            * The physical units encoded by this visualization postprocessor.

source/mesh_deformation/interface.cc

@@ -176,20 +176,6 @@ namespace aspect
 
 
 
-    template <int dim>
-    void
-    Interface<dim>::save (std::map<std::string,std::string> &) const
-    {}
-
-
-
-    template <int dim>
-    void
-    Interface<dim>::load (const std::map<std::string,std::string> &)
-    {}
-
-
-
     template <int dim>
     Tensor<1,dim>
     Interface<dim>::

source/plugins.cc

@@ -46,5 +46,16 @@ namespace aspect
     void
     InterfaceBase::parse_parameters (dealii::ParameterHandler &)
     {}
+
+
+    void
+    InterfaceBase::save (std::map<std::string,std::string> &) const
+    {}
+
+
+
+    void
+    InterfaceBase::load (const std::map<std::string,std::string> &)
+    {}
   }
 }

source/postprocess/interface.cc

@@ -40,20 +40,6 @@ namespace aspect
 
 
 
-    template <int dim>
-    void
-    Interface<dim>::save (std::map<std::string,std::string> &) const
-    {}
-
-
-
-    template <int dim>
-    void
-    Interface<dim>::load (const std::map<std::string,std::string> &)
-    {}
-
-
-
 // ------------------------------ Manager -----------------------------
 
 

source/postprocess/visualization.cc

@@ -261,19 +261,6 @@ namespace aspect
 
 
 
-      template <int dim>
-      void
-      Interface<dim>::save (std::map<std::string,std::string> &) const
-      {}
-
-
-      template <int dim>
-      void
-      Interface<dim>::load (const std::map<std::string,std::string> &)
-      {}
-
-
-
       template <int dim>
       CellDataVectorCreator<dim>::CellDataVectorCreator (const std::string &physical_units)
         :