Factory.h

#ifndef UTIL_FACTORY_H
#define UTIL_FACTORY_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/mpi/MpiFileIo.h>         // member
#include <util/param/ParamComposite.h>  // used in implementation
#include <util/param/Begin.h>           // used in implementation
#include <util/param/End.h>             // used in implementation
#include <util/global.h>

#ifdef UTIL_MPI
#include <util/mpi/MpiSendRecv.h>
#endif

#include <string>

namespace Util
{

   template <typename Data>
   class Factory
   {

   public:

      Factory();

      virtual ~Factory();

      void addSubfactory(Factory<Data>& subfactory);

      virtual Data* factory(const std::string &className) const = 0;

      Data* readObject(std::istream &in, ParamComposite& parent,
                       std::string& className, bool& isEnd);

      Data* loadObject(Serializable::IArchive& ar, ParamComposite& parent,
                       std::string& className);

   protected:

      Data* trySubfactories(const std::string& className) const;

      #ifdef UTIL_MPI

      void setIoCommunicator(MPI::Intracomm& communicator);

      bool hasIoCommunicator() const;
      #endif

   private:

      std::vector< Factory<Data>* > subfactories_;

      MpiFileIo   paramFileIo_;

   };

   /*
   * Constructor.
   */
   template <typename Data>
   Factory<Data>::Factory()
    : paramFileIo_()
   {}

   /*
   * Destructor.
   */
   template <typename Data>
   Factory<Data>::~Factory()
   {}

   #ifdef UTIL_MPI
   /*
   * Set the param communicator.
   */
   template <typename Data>
   void Factory<Data>::setIoCommunicator(MPI::Intracomm& communicator)
   {
      if (paramFileIo_.hasIoCommunicator()) {
         if (&paramFileIo_.ioCommunicator() != &communicator) {
            UTIL_THROW("Attempt to modify Factory param communicator");
         }
      } else {
         paramFileIo_.setIoCommunicator(communicator);
      }
   }

   /*
   * Does thus factory have a param communicator?
   */
   template <typename Data>
   bool Factory<Data>::hasIoCommunicator() const
   {  return paramFileIo_.hasIoCommunicator(); }
   #endif

   /*
   * Add a subfactory to the list of children.
   */
   template <typename Data>
   void Factory<Data>::addSubfactory(Factory<Data>& subfactory)
   {  subfactories_.push_back(&subfactory); }




   /*
   * Read subclass name, create object, and read its parameters.
   */
   template <typename Data>
   Data* Factory<Data>::readObject(std::istream &in, ParamComposite& parent,
                                   std::string& className, bool& isEnd)
   {
      std::string  commentString;
      Data*        typePtr = 0;
      int          length;
      bool         hasData = false; // initialized to avoid compiler warning

      #ifdef UTIL_MPI
      // Set ioCommunicator to that of parent, if any.
      if (parent.hasIoCommunicator()) {
         setIoCommunicator(parent.ioCommunicator());
      }
      #endif

      // Read a first line of the form "ClassName{"
      if (paramFileIo_.isIoProcessor()) {
         in >> commentString;
      }
      #ifdef UTIL_MPI
      // Broadcast the full string to all processors.
      if (paramFileIo_.hasIoCommunicator()) {
         bcast<std::string>(paramFileIo_.ioCommunicator(), commentString, 0);
      }
      // Hereafter, each processor independently processes the same string.
      #endif
      length = commentString.size();

      // If commentString = '}', set isEnd=true and return null ptr.
      if (length == 1 && commentString[0] == '}') {
         className = std::string();
         isEnd = true;
         return 0; 
      } else {
         isEnd = false;
      }

      // Isolate className by stripping the trailing "{" bracket
      if (commentString[length-1] == '{') {
         className = commentString.substr(0, commentString.size() - 1);
         hasData = true;
      } else
      if (commentString[length-1] == '}') {
         className = commentString.substr(0, commentString.size() - 2);
         hasData = false;
      } else {
         if (paramFileIo_.isIoProcessor()) {
            Log::file() << "commentString = " << commentString << std::endl;
            Log::file() << "className     = " << className     << std::endl;
            UTIL_THROW("Invalid first line\n");
         }
      }

      // Create new object of the specified class.
      typePtr = factory(className);

      // If the subclass name was recognized:
      if (typePtr) {

         // Add Begin object to new child ParamComposite, indented for child.
         Begin* beginPtr;
         beginPtr = &typePtr->addBegin(className.c_str());
         beginPtr->setIndent(parent);

         // Echo Begin object, if appropriate
         if (ParamComponent::echo() && paramFileIo_.isIoProcessor()) {
            beginPtr->writeParam(Log::file());
         }

         // Read parameters for the new child object, if any
         if (hasData) {
            parent.addParamComposite(*typePtr);
            typePtr->readParameters(in);
         }

         // Read closing bracket, set indentation as for child.
         typePtr->readEnd(in).setIndent(parent);

         // Note: The readParameters() methods for managed objects should 
         // not read begin and end lines, which read here. 

      }
      return typePtr;
   }

   /*
   * Load subclass name, create object, and load object.
   */
   template <typename Data>
   Data* Factory<Data>::loadObject(Serializable::IArchive& ar, ParamComposite& parent,
                                   std::string& className)
   {
      #ifdef UTIL_MPI
      // Set ioCommunicator to that of parent, if any.
      if (parent.hasIoCommunicator()) {
         setIoCommunicator(parent.ioCommunicator());
      }
      #endif

      // Read the class name.
      if (paramFileIo_.isIoProcessor()) {
         ar & className;
      }

      #ifdef UTIL_MPI
      // Broadcast the full string to all processors.
      if (paramFileIo_.hasIoCommunicator()) {
         bcast<std::string>(paramFileIo_.ioCommunicator(), className, 0);
      }
      #endif

      // Create and load a new object of the specified class.
      Data* typePtr = factory(className);
      if (typePtr) {
         parent.loadParamComposite(ar, *typePtr);
      } else {
         Log::file() << "Failed attempt to create instance of " 
                     << className << std::endl;
      }
      return typePtr;
   }

   /*
   * Try all subfactories in sequence searching for a match.
   */
   template <typename Data>
   Data* Factory<Data>::trySubfactories(const std::string& className) const
   {
      Data* typePtr = 0;
      int n = subfactories_.size();
      for (int i = 0; i < n && typePtr == 0; ++i) {
         typePtr = subfactories_[i]->factory(className);
      }
      return typePtr;
   }

}
#endif