CArrayParam.h

#ifndef UTIL_CARRAY_PARAM_H
#define UTIL_CARRAY_PARAM_H
 
#include <util/param/ArrayParam.h>
#include <util/global.h>
 
#ifdef UTIL_MPI
#include <util/mpi/MpiSendRecv.h>
#endif
 
#include <iomanip> 
 
namespace Util
{
 
   template <class Type>
   class CArrayParam : public ArrayParam<Type>
   {
   
   public:
 
      CArrayParam(const char* label, Type* value, int n, 
                  bool isRequired = true);
 
      using ArrayParam<Type>::writeParam;
 
   protected:
 
      using ArrayParam<Type>::readValue;
      using ArrayParam<Type>::n;
 
      Type& element(int i) 
      {  return value_[i]; }
 
      Type const & element(int i) const
      {  return value_[i]; }
 
      virtual void loadValue(Serializable::IArchive& ar);
 
      virtual void saveValue(Serializable::OArchive& ar);
 
      #ifdef UTIL_MPI
      virtual void bcastValue();
      #endif
 
   private:
   
      Type* value_;
  
   };
 
   /*
   * CArrayParam<Type> constructor.
   */
   template <class Type>
   CArrayParam<Type>::CArrayParam(const char *label, Type* value, int n, 
                                  bool isRequired)
    : ArrayParam<Type>(label, n, isRequired),
      value_(value)
   {}
 
   /*
   * Load C-array of n values from an input archive
   */
   template <class Type>
   void CArrayParam<Type>::loadValue(Serializable::IArchive& ar)
   {  ar.unpack(value_, n()); }
 
   /*
   * Save C-array of n values to an output archive
   */
   template <class Type>
   void CArrayParam<Type>::saveValue(Serializable::OArchive& ar)
   {  ar.pack(value_, n()); }
 
   #ifdef UTIL_MPI
   /*
   * Broadcast an array of n values
   */
   template <class Type>
   void CArrayParam<Type>::bcastValue()
   {  bcast<Type>(ioCommunicator(), value_, n(), 0); }
   #endif
 
} 
#endif