Setable.h

#ifndef UTIL_SETABLE_H
#define UTIL_SETABLE_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/global.h>

namespace Util
{

   template <class T>
   class Setable
   {

   public:

      Setable()
       : value_(),
         isSet_(false)
      {}

      Setable(const Setable<T>& other)
       : value_(other.value_),
         isSet_(other.isSet_)
      {}

      explicit Setable(const T& value)
       : value_(value),
         isSet_(true)
      {}

      Setable<T>& operator = (const Setable<T>& other)
      {
         if (this != &other) {
            isSet_ = other.isSet_;
            if (other.isSet_) {
               value_ = other.value_;
            }
         }
         return *this;
      }

      Setable<T>& operator = (const T& value)
      {
         value_ = value;
         isSet_ = true;
         return *this;
      }

      void set(const T& value)
      {
         value_ = value;
         isSet_ = true;
      }

      void unset()
      {  isSet_ = false; }

      bool isSet() const
      {  return isSet_; }

      const T& value() const
      {
         if (!isSet_) {
            UTIL_THROW("Attempt to return unknown value.");
         }
         return value_;
      }

      #ifdef UTIL_MPI

      bool isValid(MPI::Intracomm& communicator) const;
      #endif

   private:

      T value_;

      bool isSet_;

   };

   #ifdef UTIL_MPI
   template <typename T>
   bool Setable<T>::isValid(MPI::Intracomm& communicator) const
   {
      int isSet = (int)isSet_;
      int total = 0;
      communicator.Allreduce(&isSet, &total, 1, MPI::INT, MPI::SUM);
      int nproc = communicator.Get_size();
      if (isSet_ && total != nproc) {
         UTIL_THROW("Inconsistent settings");
      }
      if ((!isSet_) && total != 0) {
         UTIL_THROW("Inconsistent settings");
      }
      return true;
   }
   #endif

}
#endif