ParamComposite.h

#ifndef UTIL_PARAM_COMPOSITE_H
#define UTIL_PARAM_COMPOSITE_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>
#include <util/param/ParamComponent.h>     // base class
#include <util/param/ScalarParam.h>        // member function template
#include <util/param/CArrayParam.h>        // member function template
#include <util/param/DArrayParam.h>        // member function template
#include <util/param/FArrayParam.h>        // member function template
#include <util/param/CArray2DParam.h>      // member function template
#include <util/param/DMatrixParam.h>       // member function template
#include <util/param/DSymmMatrixParam.h>       // member function template
#include <util/archives/Serializable_includes.h>

#include <vector>

namespace Util
{

   class Begin;
   class End;
   class Blank;
   template <class Data> class Factory;

   class ParamComposite : public ParamComponent
   {

   public:

      ParamComposite();

      ParamComposite(const ParamComposite& other);

      ParamComposite(int capacity);

      virtual ~ParamComposite();

      void resetParam();



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

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

      virtual void readParameters(std::istream &in)
      {};

      virtual void writeParam(std::ostream &out);



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

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

      virtual void loadParameters(Serializable::IArchive &ar)
      {};

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

      void saveOptional(Serializable::OArchive &ar);



      void
      readParamComposite(std::istream &in, ParamComposite &child,
                         bool next = true);

      void
      readParamCompositeOptional(std::istream &in,
                                ParamComposite &child, bool next = true);

      template <typename Type>
      ScalarParam<Type>& read(std::istream &in, const char *label, 
                              Type &value);

      template <typename Type>
      ScalarParam<Type>& 
      readOptional(std::istream &in, const char *label, Type &value);

      template <typename Type>
      CArrayParam<Type>&
      readCArray(std::istream &in, const char *label, Type *value, int n);

      template <typename Type>
      CArrayParam<Type>&
      readOptionalCArray(std::istream &in, const char *label, 
                         Type *value, int n);

      template <typename Type>
      DArrayParam<Type>&
      readDArray(std::istream &in, const char *label,
                 DArray<Type>& array, int n);

      template <typename Type>
      DArrayParam<Type>&
      readOptionalDArray(std::istream &in, const char *label,
                         DArray<Type>& array, int n);

      template <typename Type, int N>
      FArrayParam<Type, N>&
      readFArray(std::istream &in, const char *label, 
                 FArray<Type, N >& array);

      template <typename Type, int N>
      FArrayParam<Type, N>&
      readOptionalFArray(std::istream &in, const char *label, 
                         FArray<Type, N >& array);

      template <typename Type>
      CArray2DParam<Type>&
      readCArray2D(std::istream &in, const char *label,
                   Type *value, int m, int n, int np);

      template <typename Type>
      CArray2DParam<Type>&
      readOptionalCArray2D(std::istream &in, const char *label,
                           Type *value, int m, int n, int np);

      template <typename Type>
      DMatrixParam<Type>&
      readDMatrix(std::istream &in, const char *label,
                  DMatrix<Type>& matrix, int m, int n);

      template <typename Type>
      DMatrixParam<Type>&
      readOptionalDMatrix(std::istream &in, const char *label,
                          DMatrix<Type>& matrix, int m, int n);

      template <typename Type>
      DSymmMatrixParam<Type>&
      readDSymmMatrix(std::istream &in, const char *label,
                      DMatrix<Type>& matrix, int n);

      template <typename Type>
      DSymmMatrixParam<Type>&
      readOptionalDSymmMatrix(std::istream &in, const char *label,
                              DMatrix<Type>& matrix, int n);

      Begin& readBegin(std::istream &in, const char* label,
                       bool isRequired = true);

      End& readEnd(std::istream &in);

      Blank& readBlank(std::istream &in);



      void
      loadParamComposite(Serializable::IArchive &ar, 
                         ParamComposite &child, bool next = true);

      void
      loadParamCompositeOptional(Serializable::IArchive &ar,
                                 ParamComposite &child, bool next = true);

      template <typename Type>
      ScalarParam<Type>& loadParameter(Serializable::IArchive &ar,
                                       const char *label, Type &value,
                                       bool isRequired);

      template <typename Type>
      ScalarParam<Type>& loadParameter(Serializable::IArchive &ar,
                                       const char *label, Type &value);

      template <typename Type>
      CArrayParam<Type>&
      loadCArray(Serializable::IArchive &ar, const char *label,
                 Type *value, int n, bool isRequired);

      template <typename Type>
      CArrayParam<Type>&
      loadCArray(Serializable::IArchive &ar, const char *label,
                 Type *value, int n);

      template <typename Type>
      DArrayParam<Type>&
      loadDArray(Serializable::IArchive &ar, const char *label,
                 DArray<Type>& array, int n, bool isRequired);

      template <typename Type>
      DArrayParam<Type>&
      loadDArray(Serializable::IArchive &ar, const char *label,
                 DArray<Type>& array, int n);

      template <typename Type, int N>
      FArrayParam<Type, N>&
      loadFArray(Serializable::IArchive &ar, const char *label,
                 FArray<Type, N >& array, bool isRequired);

      template <typename Type, int N>
      FArrayParam<Type, N>&
      loadFArray(Serializable::IArchive &ar, const char *label,
                 FArray<Type, N >& array)
      {  return loadFArray<Type, N>(ar, label, array, true); }

      template <typename Type>
      CArray2DParam<Type>&
      loadCArray2D(Serializable::IArchive &ar, const char *label,
                   Type *value, int m, int n, int np, bool isRequired);

      template <typename Type>
      CArray2DParam<Type>&
      loadCArray2D(Serializable::IArchive &ar, const char *label,
                   Type *value, int m, int n, int np);

      template <typename Type>
      DMatrixParam<Type>&
      loadDMatrix(Serializable::IArchive &ar, const char *label,
                  DMatrix<Type>& matrix, int m, int n, bool isRequired);

      template <typename Type>
      DMatrixParam<Type>&
      loadDMatrix(Serializable::IArchive &ar, const char *label,
                  DMatrix<Type>& matrix, int m, int n);

      template <typename Type>
      DSymmMatrixParam<Type>&
      loadDSymmMatrix(Serializable::IArchive &ar, const char *label,
                      DMatrix<Type>& matrix, int n, bool isRequired);

      template <typename Type>
      DSymmMatrixParam<Type>&
      loadDSymmMatrix(Serializable::IArchive &ar, const char *label,
                      DMatrix<Type>& matrix, int n);




      void addParamComposite(ParamComposite& child, bool next = true);

      Begin& addBegin(const char* label);

      End& addEnd();

      Blank& addBlank();



      std::string className() const;

      bool isRequired() const;

      bool isActive() const;


   protected:

      void setClassName(const char* className);

      void setIsRequired(bool isRequired);

      void setIsActive(bool isActive);

      void setParent(ParamComponent& param, bool next = true);

      void addComponent(ParamComponent& param, bool isLeaf = true);

      template <typename Type>
      ScalarParam<Type>& add(std::istream &in, const char *label, 
                            Type &value, bool isRequired = true);

      template <typename Type>
      CArrayParam<Type>&
      addCArray(std::istream &in, const char *label, 
                Type *value, int n, bool isRequired = true);

      template <typename Type>
      DArrayParam<Type>&
      addDArray(std::istream &in, const char *label,
                DArray<Type>& array, int n, bool isRequired = true);

      template <typename Type, int N>
      FArrayParam<Type, N>&
      addFArray(std::istream &in, const char *label, 
                FArray<Type, N >& array, bool isRequired = true);

      template <typename Type>
      CArray2DParam<Type>&
      addCArray2D(std::istream &in, const char *label,
                  Type *value, int m, int n, int np, 
                  bool isRequired = true);

      template <typename Type>
      DMatrixParam<Type>&
      addDMatrix(std::istream &in, const char *label,
                 DMatrix<Type>& matrix, int m, int n, 
                 bool isRequired = true);

   private:

      std::vector<ParamComponent*> list_;

      std::vector<bool> isLeaf_;

      int size_;

      std::string className_;

      bool isRequired_;

      bool isActive_;

      template <typename Type>
      ScalarParam<Type>& read_(std::istream &in, const char *label, 
                               Type &value, bool isRequired);

      template <typename Type>
      CArrayParam<Type>&
      readCArray_(std::istream &in, const char *label, Type *value, 
                  int n, bool isRequired);

      template <typename Type> 
      DArrayParam<Type>& 
      readDArray_(std::istream &in, const char *label,
                  DArray<Type>& array, int n, bool isRequired);

      template <typename Type, int N>
      FArrayParam<Type, N>&
      readFArray_(std::istream &in, const char *label, 
                 FArray<Type, N >& array, bool isRequired);

      template <typename Type>
      CArray2DParam<Type>&
      readCArray2D_(std::istream &in, const char *label,
                   Type *value, int m, int n, int np, bool isRequired);

      template <typename Type>
      DMatrixParam<Type>&
      readDMatrix_(std::istream &in, const char *label, 
                   DMatrix<Type>& matrix, int m, int n, bool isRequired);

      template <typename Type>
      DSymmMatrixParam<Type>&
      readDSymmMatrix_(std::istream &in, const char *label, 
                   DMatrix<Type>& matrix, int n, bool isRequired);

   };

   // Inline accessor functions

   /*
   * Get class name string.
   */
   inline std::string ParamComposite::className() const
   {  return className_; }

   /*
   * Is this ParamComposite required in the input file?
   */
   inline bool ParamComposite::isRequired() const
   { return isRequired_; }

   /*
   * Is this parameter active?
   */
   inline bool ParamComposite::isActive() const
   { return isActive_; }

   // Function templates for scalar parameters

   /*
   * Add and read a scalar parameter (private).
   */
   template <typename Type>
   ScalarParam<Type>&
   ParamComposite::read_(std::istream &in, const char *label, Type &value,
                        bool isRequired)
   {
      ScalarParam<Type>* ptr;
      ptr = new ScalarParam<Type>(label, value, isRequired);
      setParent(*ptr);
      ptr->readParam(in);
      addComponent(*ptr);
      return *ptr;
   }

   /*
   * Add (but do not read) a scalar parameter (protected).
   */
   template <typename Type>
   ScalarParam<Type>&
   ParamComposite::add(std::istream &in, const char *label, Type &value,
                       bool isRequired)
   {
      ScalarParam<Type>* ptr;
      ptr = new ScalarParam<Type>(label, value, isRequired);
      setParent(*ptr);
      addComponent(*ptr);
      return *ptr;
   }

   /*
   * Add and read a required scalar parameter.
   */
   template <typename Type>
   ScalarParam<Type>& 
   ParamComposite::read(std::istream &in, const char *label, Type &value)
   {  return read_<Type>(in, label, value, true); }

   /*
   * Add and read a new optional ScalarParam < Type > object.
   */
   template <typename Type>
   inline ScalarParam<Type>& 
   ParamComposite::readOptional(std::istream &in, const char *label, 
                                Type &value)
   {  return read_<Type>(in, label, value, false); }

   /*
   * Add a new ScalarParam< Type > object, and load its value from an archive.
   */
   template <typename Type>
   ScalarParam<Type>&
   ParamComposite::loadParameter(Serializable::IArchive &ar, const char *label,
                                 Type &value, bool isRequired)
   {
      ScalarParam<Type>* ptr;
      ptr = new ScalarParam<Type>(label, value, isRequired);
      setParent(*ptr);
      ptr->load(ar);
      addComponent(*ptr);
      return *ptr;
   }

   /*
   * Add a new required ScalarParam< Type > object, and load from an archive.
   */
   template <typename Type>
   inline ScalarParam<Type>&
   ParamComposite::loadParameter(Serializable::IArchive &ar, const char *label,
                                 Type &value)
   {  return loadParameter<Type>(ar, label, value, true); }

   // Templates for 1D C Arrays

   /*
   * Add and read a CArrayParam associated with a built-in C-array (private).
   */
   template <typename Type>
   CArrayParam<Type>&
   ParamComposite::readCArray_(std::istream &in, const char *label,
                              Type *value, int n, bool isRequired)
   {
      CArrayParam<Type>* ptr;
      ptr = new CArrayParam<Type>(label, value, n, isRequired);
      setParent(*ptr);
      ptr->readParam(in);
      addComponent(*ptr);
      return *ptr;
   }

   /*
   * Add a CArrayParam built-in C-array parameter (protected).
   */
   template <typename Type>
   CArrayParam<Type>&
   ParamComposite::addCArray(std::istream &in, const char *label,
                             Type *value, int n, bool isRequired)
   {
      CArrayParam<Type>* ptr;
      ptr = new CArrayParam<Type>(label, value, n, isRequired);
      setParent(*ptr);
      addComponent(*ptr);
      return *ptr;
   }

   /*
   * Add and read a required CArrayParam.
   */
   template <typename Type>
   inline CArrayParam<Type>&
   ParamComposite::readCArray(std::istream &in, const char *label, 
                              Type *value, int n)
   {  return readCArray_<Type>(in, label, value, n, true); }

   /*
   * Add and read an optional CArrayParam.
   */
   template <typename Type>
   inline CArrayParam<Type>&
   ParamComposite::readOptionalCArray(std::istream &in, const char *label, 
                                      Type *value, int n)
   {  return readCArray_<Type>(in, label, value, n, false); }

   /*
   * Add and load a C array parameter.
   */
   template <typename Type>
   CArrayParam<Type>&
   ParamComposite::loadCArray(Serializable::IArchive &ar, const char *label,
                              Type *value, int n, bool isRequired)
   {
      CArrayParam<Type>* ptr;
      ptr = new CArrayParam<Type>(label, value, n, isRequired);
      setParent(*ptr);
      ptr->load(ar);
      addComponent(*ptr);
      return *ptr;
   }

   /*
   * Add and load a required C array parameter.
   */
   template <typename Type>
   inline CArrayParam<Type>&
   ParamComposite::loadCArray(Serializable::IArchive &ar, const char *label,
                              Type *value, int n)
   {  return loadCArray<Type>(ar, label, value, n, true); }

   // Templates for DArray parameters

   /*
   * Add and read a DArrayParam associated with a DArray<Type> (private).
   */
   template <typename Type>
   DArrayParam<Type>&
   ParamComposite::readDArray_(std::istream &in, const char *label,
                              DArray<Type>& array, int n, bool isRequired)
   {
      DArrayParam<Type>* ptr;
      ptr = new DArrayParam<Type>(label, array, n, isRequired);
      setParent(*ptr);
      ptr->readParam(in);
      addComponent(*ptr);
      return *ptr;
   }

   /*
   * Add a DArray<Type> DArray parameter (protected).
   */
   template <typename Type>
   DArrayParam<Type>&
   ParamComposite::addDArray(std::istream &in, const char *label,
                             DArray<Type>& array, int n, bool isRequired)
   {
      DArrayParam<Type>* ptr;
      ptr = new DArrayParam<Type>(label, array, n, isRequired);
      setParent(*ptr);
      addComponent(*ptr);
      return *ptr;
   }

   /*
   * Add and read a required DArrayParam.
   */
   template <typename Type>
   inline 
   DArrayParam<Type>&
   ParamComposite::readDArray(std::istream &in, const char *label,
              DArray<Type>& array, int n)
   {  return readDArray_<Type>(in, label, array, n, true); }

   /*
   * Add and read an optional DArrayParam.
   */
   template <typename Type>
   inline 
   DArrayParam<Type>&
   ParamComposite::readOptionalDArray(std::istream &in, const char *label,
              DArray<Type>& array, int n)
   {  return readDArray_<Type>(in, label, array, n, false); }

   /*
   * Add a DArray < Type > parameter, and load its elements.
   */
   template <typename Type>
   DArrayParam<Type>&
   ParamComposite::loadDArray(Serializable::IArchive &ar, const char* label,
                              DArray<Type>& array, int n, bool isRequired)
   {
      DArrayParam<Type>* ptr;
      ptr = new DArrayParam<Type>(label, array, n, isRequired);
      setParent(*ptr);
      ptr->load(ar);
      addComponent(*ptr);
      return *ptr;
   }

   /*
   * Add a required DArray < Type > parameter, and load its elements.
   */
   template <typename Type>
   inline DArrayParam<Type>&
   ParamComposite::loadDArray(Serializable::IArchive &ar, const char *label,
                              DArray<Type>& array, int n)
   {  return loadDArray<Type>(ar, label, array, n, true); }

   // Templates for fixed size FArray array objects.

   /*
   * Add and read an FArrayParam<Type, N> fixed size array (private).
   */
   template <typename Type, int N>
   FArrayParam<Type, N>&
   ParamComposite::readFArray_(std::istream &in, const char *label,
                              FArray<Type, N>& array, bool isRequired)
   {
      FArrayParam<Type, N>* ptr;
      ptr = new FArrayParam<Type, N>(label, array, isRequired);
      setParent(*ptr);
      ptr->readParam(in);
      addComponent(*ptr);
      return *ptr;
   }

   /*
   * Add a FArrayParam<Type, N> parameter (protected).
   */
   template <typename Type, int N>
   FArrayParam<Type, N>&
   ParamComposite::addFArray(std::istream &in, const char *label,
                             FArray<Type, N>& array, bool isRequired)
   {
      FArrayParam<Type, N>* ptr;
      ptr = new FArrayParam<Type, N>(label, array, isRequired);
      setParent(*ptr);
      addComponent(*ptr);
      return *ptr;
   }

   /*
   * Add and read a required FArray < Type, N > array parameter.
   */
   template <typename Type, int N>
   inline 
   FArrayParam<Type, N>&
   ParamComposite::readFArray(std::istream &in, const char *label, 
                              FArray<Type, N >& array)
   {  return readFArray_<Type>(in, label, array, true); }

   /*
   * Add and read an optional FArray < Type, N > array parameter.
   */
   template <typename Type, int N>
   inline 
   FArrayParam<Type, N>&
   ParamComposite::readOptionalFArray(std::istream &in, const char *label, 
                                      FArray<Type, N >& array)
   {  return readFArray_<Type>(in, label, array, false); }

   /*
   * Add and load an FArray < Type, N > fixed-size array parameter.
   */
   template <typename Type, int N>
   FArrayParam<Type, N>&
   ParamComposite::loadFArray(Serializable::IArchive &ar, const char *label,
                              FArray<Type, N >& array, bool isRequired)
   {
      FArrayParam<Type, N>* ptr;
      ptr = new FArrayParam<Type, N>(label, array, isRequired);
      setParent(*ptr);
      ptr->load(ar);
      addComponent(*ptr);
      return *ptr;
   }

   // Templates for built-in two-dimensional C Arrays

   /*
   * Add and read a CArray2DParam 2D C array (private).
   */
   template <typename Type>
   CArray2DParam<Type>&
   ParamComposite::readCArray2D_(std::istream &in, const char *label,
                                Type *value, int m, int n, int np,
                                bool isRequired)
   {
      CArray2DParam<Type>* ptr;
      ptr = new CArray2DParam<Type>(label, value, m, n, np, isRequired);
      setParent(*ptr);
      ptr->readParam(in);
      addComponent(*ptr);
      return *ptr;
   }

   /*
   * Add a CArray2DParam 2D C array (protected).
   */
   template <typename Type>
   CArray2DParam<Type>&
   ParamComposite::addCArray2D(std::istream &in, const char *label,
                               Type *value, int m, int n, int np,
                               bool isRequired)
   {
      CArray2DParam<Type>* ptr;
      ptr = new CArray2DParam<Type>(label, value, m, n, np, isRequired);
      setParent(*ptr);
      addComponent(*ptr);
      return *ptr;
   }

   /*
   * Add and read a required CArray2DParam.
   */
   template <typename Type>
   inline CArray2DParam<Type>&
   ParamComposite::readCArray2D(std::istream &in, const char *label,
                                Type *value, int m, int n, int np)
   {  return readCArray2D_<Type>(in, label, value, m, n, np, true); }

   /*
   * Add and read an optional CArray2DParam.
   */
   template <typename Type>
   inline CArray2DParam<Type>&
   ParamComposite::readOptionalCArray2D(std::istream &in, 
                                        const char *label, Type *value, 
                                        int m, int n, int np)
   {  return readCArray2D_<Type>(in, label, value, m, n, np, false); }

   /*
   * Add and load a CArray2DParam < Type > 2D C array parameter.
   */
   template <typename Type>
   CArray2DParam<Type>&
   ParamComposite::loadCArray2D(Serializable::IArchive &ar, 
                                const char *label,
                                Type *value, int m, int n, int np,
                                bool isRequired)
   {
      CArray2DParam<Type>* ptr;
      ptr = new CArray2DParam<Type>(label, value, m, n, np, isRequired);
      setParent(*ptr);
      ptr->load(ar);
      addComponent(*ptr);
      return *ptr;
   }

   /*
   * Add and load a required CArray2DParam < Type > 2D C array.
   */
   template <typename Type>
   CArray2DParam<Type>&
   ParamComposite::loadCArray2D(Serializable::IArchive &ar, 
                                const char *label,
                                Type *value, int m, int n, int np)
   {  return loadCArray2D<Type>(ar, label, value, m, n, np, true); }

   // Templates for DMatrix containers

   /*
   * Add and read a DMatrixParam DMatrix<Type> parameter (private).
   */
   template <typename Type>
   DMatrixParam<Type>&
   ParamComposite::readDMatrix_(std::istream &in, const char *label,
                               DMatrix<Type>& matrix, int m, int n,
                               bool isRequired)
   {
      DMatrixParam<Type>* ptr;
      ptr = new DMatrixParam<Type>(label, matrix, m, n, isRequired);
      setParent(*ptr);
      ptr->readParam(in);
      addComponent(*ptr);
      return *ptr;
   }

   /*
   * Add a DMatrixParam DMatrix<Type> parameter (protected).
   */
   template <typename Type>
   DMatrixParam<Type>&
   ParamComposite::addDMatrix(std::istream &in, const char *label,
                              DMatrix<Type>& matrix, int m, int n,
                              bool isRequired)
   {
      DMatrixParam<Type>* ptr;
      ptr = new DMatrixParam<Type>(label, matrix, m, n, isRequired);
      setParent(*ptr);
      addComponent(*ptr);
      return *ptr;
   }

   /*
   * Add and read a required DMatrixParam.
   */
   template <typename Type>
   inline DMatrixParam<Type>&
   ParamComposite::readDMatrix(std::istream &in, const char *label,
                               DMatrix<Type>& matrix, int m, int n)
   {  return readDMatrix_<Type>(in, label, matrix, m, n, true); }

   /*
   * Add and read an optional DMatrixParam.
   */
   template <typename Type>
   inline DMatrixParam<Type>&
   ParamComposite::readOptionalDMatrix(std::istream &in, const char *label,
                               DMatrix<Type>& matrix, int m, int n)
   {  return readDMatrix_<Type>(in, label, matrix, m, n, false); }

   /*
   * Add and load a DMatrix < Type > C two-dimensional matrix parameter.
   */
   template <typename Type>
   DMatrixParam<Type>&
   ParamComposite::loadDMatrix(Serializable::IArchive &ar, const char *label,
                               DMatrix<Type>& matrix, int m, int n,
                               bool isRequired)
   {
      DMatrixParam<Type>* ptr;
      ptr = new DMatrixParam<Type>(label, matrix, m, n, isRequired);
      setParent(*ptr);
      ptr->load(ar);
      addComponent(*ptr);
      return *ptr;
   }

   /*
   * Add and load a required DMatrixParam< Type> matrix parameter.
   */
   template <typename Type>
   inline DMatrixParam<Type>&
   ParamComposite::loadDMatrix(Serializable::IArchive &ar, const char *label,
                               DMatrix<Type>& matrix, int m, int n)
   {  return loadDMatrix<Type>(ar, label, matrix, m, n, true); }

   // Templates for Symmetric DMatrix containers

   /*
   * Add and read a symmetric DMatrixParam DMatrix (private).
   */
   template <typename Type>
   DSymmMatrixParam<Type>&
   ParamComposite::readDSymmMatrix_(std::istream &in, 
                                    const char *label,
                                    DMatrix<Type>& matrix, 
                                    int n,
                                    bool isRequired)
   {
      DSymmMatrixParam<Type>* ptr;
      ptr = new DSymmMatrixParam<Type>(label, matrix, n, isRequired);
      setParent(*ptr);
      ptr->readParam(in);
      addComponent(*ptr);
      return *ptr;
   }

   /*
   * Add and read a required DMatrixParam.
   */
   template <typename Type>
   inline DSymmMatrixParam<Type>&
   ParamComposite::readDSymmMatrix(std::istream& in, 
                                   const char *label,
                                   DMatrix<Type>& matrix, 
                                   int n)
   {  return readDSymmMatrix_<Type>(in, label, matrix, n, true); }

   /*
   * Add and read an optional DMatrixParam.
   */
   template <typename Type>
   inline DSymmMatrixParam<Type>&
   ParamComposite::readOptionalDSymmMatrix(std::istream &in, 
                                           const char *label,
                                           DMatrix<Type>& matrix, 
                                           int n)
   {  return readDMatrix_<Type>(in, label, matrix, n, false); }

   /*
   * Add and load a DMatrix < Type > C two-dimensional matrix parameter.
   */
   template <typename Type>
   DSymmMatrixParam<Type>&
   ParamComposite::loadDSymmMatrix(Serializable::IArchive &ar, 
                                   const char *label,
                                   DMatrix<Type>& matrix, 
                                   int n,
                                   bool isRequired)
   {
      DSymmMatrixParam<Type>* ptr;
      ptr = new DSymmMatrixParam<Type>(label, matrix, n, isRequired);
      setParent(*ptr);
      ptr->load(ar);
      addComponent(*ptr);
      return *ptr;
   }

   /*
   * Add and load a required DMatrixParam< Type> matrix parameter.
   */
   template <typename Type>
   inline DSymmMatrixParam<Type>&
   ParamComposite::loadDSymmMatrix(Serializable::IArchive &ar, 
                                   const char *label,
                                   DMatrix<Type>& matrix, 
                                   int n)
   {  return loadDSymmMatrix<Type>(ar, label, matrix, n, true); }

}
#endif