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);

      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)
   {
      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