Parameter.h

#ifndef UTIL_PARAMETER_H
#define UTIL_PARAMETER_H
 
/*
* Util Package - C++ Utilities for Scientific Computation
*
* Copyright 2010 - 2017, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/
 
#include <util/param/ParamComponent.h>
#include <util/archives/Serializable_includes.h>
#include <util/param/Label.h>
#include <util/global.h>
 
namespace Util
{

   class Parameter : public ParamComponent
   {
 
   public:
 
      // Static members

      static const int Width = 20;

      static const int Precision = 12;

      template <class Type>
      static void
      saveOptional(Serializable::OArchive& ar, Type& value, bool isActive);

      template <class Type>
      static void
      saveOptionalCArray(Serializable::OArchive& ar, Type* ptr, int n,
                         bool isActive);

      template <class Type>
      static void
      saveOptionalCArray2D(Serializable::OArchive& ar, Type* ptr, 
                           int m, int n, int np, bool isActive);
 
      // Non-static member functions

      Parameter(const char *label, bool isRequired = true);

      virtual ~Parameter();

      virtual void readParam(std::istream &in);

      virtual void load(Serializable::IArchive& ar);

      virtual void save(Serializable::OArchive& ar);

      std::string label() const;

      bool isRequired() const;

      bool isActive() const;
 
   protected:

      Label label_;

      bool isActive_;

      virtual void readLabel(std::istream& in);

      virtual void readValue(std::istream& in){}

      virtual void loadValue(Serializable::IArchive& ar){}

      virtual void saveValue(Serializable::OArchive& ar){}
 
      #ifdef UTIL_MPI
      virtual void bcastValue(){}
      #endif
 
   };
 
   /*
   * Save a parameter value to an output archive
   */
   template <class Type>
   void Parameter::saveOptional(Serializable::OArchive& ar, 
                                Type& value, bool isActive)
   {
      ar << isActive;
      if (isActive) {
         ar & value;
      }
   }
 
   /*
   * Save C-array of n ptrs to an output archive
   */
   template <class Type>
   void Parameter::saveOptionalCArray(Serializable::OArchive& ar, 
                                      Type* ptr, int n, bool isActive)
   {
      ar << isActive;
      if (isActive) {
         ar.pack(ptr, n);
      }
   }
 
   /*
   * Save a two-dimensional C array to an output archive.
   */
   template <class Type> 
   void Parameter::saveOptionalCArray2D(Serializable::OArchive& ar, 
                                        Type* ptr, int m, int n, int np, 
                                        bool isActive)
   {
      ar << isActive;
      if (isActive) {
         ar.pack(ptr, m, n, np);
      }
   }
 
}
#endif