Manager.h

#ifndef UTIL_MANAGER_H
#define UTIL_MANAGER_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/ParamComposite.h>  // base class
#include <util/param/Factory.h>         // pointer member, used in implementation
#include <util/global.h>
 
#include <string>
#include <vector>
 
namespace Util
{

   template <typename Data>
   class Manager : public ParamComposite
   {
 
   public:

      Manager(bool uniqueNames = false);

      virtual ~Manager();

      void addSubfactory(Factory<Data>& subfactory);

      void setFactory(Factory<Data>& factory);

      void setFactory(Factory<Data>* factoryPtr);

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

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

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

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

      void append(Data& data, const std::string& name);

      int size() const;

      std::string className(int i) const;

      Factory<Data>& factory();

      bool hasFactory() const;

      Data& operator[] (int i) const;

      Data* findFirst(std::string const & className);
 
   protected:

      Factory<Data>* factoryPtr_;

      void beginReadManager(std::istream& in);

      void endReadManager();

      virtual void initFactory();

      virtual Factory<Data>* newDefaultFactory() const;
 
   private:

      std::vector<Data*> ptrs_;

      std::vector<std::string> names_;

      int  capacity_;

      int  size_;

      bool uniqueNames_;

      bool createdFactory_;
 
   };
 
   /*
   * Constructor.
   */
   template <typename Data>
   Manager<Data>::Manager(bool uniqueNames)
    : factoryPtr_(0),
      ptrs_(),
      names_(),
      capacity_(0),
      size_(0),
      uniqueNames_(uniqueNames),
      createdFactory_(false)
   {}
 
   /*
   * Destructor.
   */
   template <typename Data>
   Manager<Data>::~Manager()
   {
      // Delete objects referenced by non-null elements of ptrs_[].
      for (int i=0; i < size_; ++i) {
         if (ptrs_[i]) {
            delete ptrs_[i];
         }
      }
 
      // Delete Factory if it was created by this Manager.
      if (factoryPtr_ && createdFactory_) {
         delete factoryPtr_;
      }
   }
 
   /*
   * Return a reference to the factory.
   */
   template <typename Data>
   Factory<Data>& Manager<Data>::factory()
   {
      initFactory();
      return *factoryPtr_;
   }
 
   /*
   * Add a subfactory to the current (or default) Factory.
   */
   template <typename Data>
   void Manager<Data>::addSubfactory(Factory<Data>& subfactory)
   {
      factory().addSubfactory(subfactory);
   }
 
   /*
   * Associate a Factory with the Manager, pass by reference.
   */
   template <typename Data>
   void Manager<Data>::setFactory(Factory<Data>& factory)
   {
      if (factoryPtr_ && createdFactory_) {
         delete factoryPtr_;
         createdFactory_ = false;
      }
      factoryPtr_ = &factory;
   }
 
   /*
   * Associate a factory with the Manager, passed by pointer.
   */
   template <typename Data>
   void Manager<Data>::setFactory(Factory<Data>* factoryPtr)
   {
      if (factoryPtr_ && createdFactory_) {
         delete factoryPtr_;
         createdFactory_ = false;
      }
      factoryPtr_ = factoryPtr;
   }
 
   /*
   * Read Manager parameter block.
   */
   template <typename Data>
   void Manager<Data>::readParam(std::istream &in)
   {
      setIsRequired(true);
      setIsActive(true);
      beginReadManager(in);
      readParameters(in);
      endReadManager();
   }
 
   /*
   * Attempt to read parameter block for optional Manager.
   */
   template <typename Data>
   void Manager<Data>::readParamOptional(std::istream &in)
   {
      setIsRequired(false);
      setIsActive(false);
      beginReadManager(in);
      if (isActive()) {
         readParameters(in);
         endReadManager();
      }
   }
 
   /*
   * Read (or attempt to read) opening line. 
   */
   template <typename Data>
   void Manager<Data>::beginReadManager(std::istream &in)
   {
      std::string managerName = ParamComposite::className();
      Begin* beginPtr = &readBegin(in, managerName.c_str(), isRequired());
      if (!isRequired()) { 
         if (beginPtr->isActive()) {
            setIsActive(true);
         } else {
            setIsActive(false);
            delete beginPtr;
         }
      }
   }
 
   /*
   * Read a sequence of child objects, return when closing bracket found.
   */
   template <typename Data>
   void Manager<Data>::readParameters(std::istream &in)
   {
      // Check if a Factory exists, create one if necessary.
      initFactory();
 
      // Loop over managed objects
      std::string name;
      Data* typePtr;
      bool  isEnd = false;
      while (!isEnd) {
 
         // Read a blank line before each object
         readBlank(in);
 
         // Attempt to read and instantiate a new object *typePtr.
         // This sets isEnd = true if a closing bracket is encountered.
         typePtr = factoryPtr_->readObject(in, *this, name, isEnd);
 
         if (!isEnd) {
            if (typePtr) {
               if (uniqueNames_) {
                  Data* firstPtr = findFirst(name);
                  if (firstPtr) {
                     std::string msg("Non-unique subclass name: ");
                     msg += name;
                     UTIL_THROW(msg.c_str());
                  }
               }
               append(*typePtr, name);
            } else {
               std::string msg("Unknown subclass name: ");
               msg += name;
               UTIL_THROW(msg.c_str());
            }
         }
 
      }
   }
 
   /*
   * Add closing bracket.
   */
   template <typename Data>
   void Manager<Data>::endReadManager()
   {
      End* endPtr = &addEnd();
      if (ParamComponent::echo() && isIoProcessor()) {
         endPtr->writeParam(Log::file());
      }
   }
 
   /*
   * Read instructions for creating objects from file.
   */
   template <typename Data>
   void Manager<Data>::loadParameters(Serializable::IArchive &ar)
   {
      int size = 0;
      Data* typePtr;
      std::string name;
 
      // Check if a Factory exists, create one if necessary.
      initFactory();
 
      if (isIoProcessor()) {
         ar >> size;
      }
      #ifdef UTIL_MPI
      if (hasIoCommunicator()) {
         bcast<int>(ioCommunicator(), size, 0);
      }
      #endif
 
      for (int i = 0; i < size; ++i) {
         addBlank();
         name = "unknown";
         typePtr = factoryPtr_->loadObject(ar, *this, name);
         if (typePtr) {
            append(*typePtr, name);
         } else {
            std::string msg("Unknown subclass name: ");
            msg += name;
            UTIL_THROW(msg.c_str());
         }
      }
      addBlank();
   }
 
   /*
   * Read instructions for creating objects from file.
   */
   template <typename Data>
   void Manager<Data>::save(Serializable::OArchive &ar)
   {
      int size = ptrs_.size();
      ar << size;
      for (int i = 0; i < size; ++i) {
         ar << names_[i];
         (ptrs_[i])->save(ar);
      }
   }
 
   /*
   * Append an object to the Manager.
   */
   template <typename Data>
   void Manager<Data>::append(Data& data, const std::string& name)
   {
      ptrs_.push_back(&data);
      names_.push_back(name);
      ++size_;
   }
 
   /*
   * Return subclass name for object number i.
   */
   template <typename Data>
   std::string Manager<Data>::className(int i) const
   {
      if (i >= size_) {
         UTIL_THROW("Invalid array index\n");
      }
      return names_[i];
   }
 
   /*
   * Does this Manager have an associated Factory?
   */
   template <typename Data>
   bool Manager<Data>::hasFactory() const
   {
      return (factoryPtr_ != 0);
   }
 
   /*
   * Return logical size (number of objects appended thus far).
   */
   template <typename Data>
   inline int Manager<Data>::size() const
   {  return size_; }
 
   /*
   * Array subscript operator - return a reference.
   */
   template <typename Data>
   inline Data& Manager<Data>::operator[] (int i) const
   {
      assert(i >= 0);
      assert(i < size_);
      return *ptrs_[i];
   }
 
   /*
   * Find first object with specified class name.
   */
   template <typename Data>
   Data* Manager<Data>::findFirst(std::string const & className)
   {
      for (int i = 0; i < size_; ++i) {
         if (names_[i] == className) {
            return ptrs_[i];
         }
      }
      return 0;
   }
 
   // Protected methods
 
   /*
   * Initialize Factory, create if necessary.
   */
   template <typename Data>
   void Manager<Data>::initFactory()
   {
      if (!hasFactory()) {
         factoryPtr_ = newDefaultFactory();
         createdFactory_ = true;
      }
      assert(factoryPtr_);
   }

   template <typename Data>
   Factory<Data>* Manager<Data>::newDefaultFactory() const
   {  
      UTIL_THROW("Call of un-implemented Manager<Data>::newDefaultFactory"); 
      return 0;
   }
 
}
#endif