ScalarParam.h

#ifndef UTIL_SCALAR_PARAM_H
#define UTIL_SCALAR_PARAM_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/Parameter.h>
#include <util/archives/Serializable_includes.h>
#include <util/global.h>
 
#ifdef UTIL_MPI
#include <util/mpi/MpiSendRecv.h>
#endif
 
#include <iomanip> 
 
namespace Util
{
 
   template <class Type>
   class ScalarParam : public Parameter
   {
   
   public:
  
      ScalarParam(const char *label, Type& value, bool isRequired = true); 
 
      void writeParam(std::ostream& out) const;
 
      void setValue(Type& value);
 
   protected:
   
      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
 
   private:
 
      Type* valuePtr_;
 
      ScalarParam(const ScalarParam<Type>& other);
 
      ScalarParam<Type> operator = (const ScalarParam<Type>& other);
   
   };
 
   // Member Function Definitions
 
   /*
   * ScalarParam<Type> constructor.
   */
   template <class Type>
   ScalarParam<Type>::ScalarParam(const char *label, Type &value, 
                                  bool isRequired)
    : Parameter(label, isRequired),
      valuePtr_(&value)
   {}
 
   template <class Type>
   void ScalarParam<Type>::readValue(std::istream &in)
   {  in >> *valuePtr_; }
 
   template <class Type>
   void ScalarParam<Type>::loadValue(Serializable::IArchive& ar)
   {  ar & *valuePtr_; }
 
   template <class Type>
   void ScalarParam<Type>::saveValue(Serializable::OArchive& ar)
   {  ar & *valuePtr_; }
 
   #ifdef UTIL_MPI
   template <class Type>
   void ScalarParam<Type>::bcastValue()
   {  bcast<Type>(ioCommunicator(), *valuePtr_, 0); }
   #endif
 
   /*
   * Write a parameter.
   */
   template <class Type>
   void ScalarParam<Type>::writeParam(std::ostream& out) const
   {
      if (isActive()) {
         out << indent();
         out << label_;
         out << std::right << std::scientific 
             << std::setprecision(Parameter::Precision) 
             << std::setw(Parameter::Width) << *valuePtr_ 
             << std::endl;
      }
   }
 
   /*
   * Set the pointer to the parameter value.
   */
   template <class Type>
   void ScalarParam<Type>::setValue(Type& value)
   {  valuePtr_ = &value; }
 
} 
#endif