BaseObject.hpp

/*
 * BaseObject.hpp
 *
 *  This is the base class for HyPerCol, layers, connections, probes, and
 *  anything else that the Factory object needs to know about.
 *
 *  All objects in the BaseObject hierarchy should have an associated
 *  instantiating function, with the prototype
 *  BaseObject * createNameOfClass(char const * name, HyPerCol * initData);
 *
 *  Each class's instantiating function should create an object of that class,
 *  with the arguments specifying the object's name and any necessary
 *  initializing data (for most classes, this is the parent HyPerCol.
 *  For HyPerCol, it is the PVInit object).  This way, the class can be
 *  registered with the Factory object by calling
 *  Factory::registerKeyword() with a pointer to the class's instantiating
 *  method.
 *
 *  Created on: Jan 20, 2016
 *      Author: pschultz
 */

#ifndef BASEOBJECT_HPP_
#define BASEOBJECT_HPP_

#include "checkpointing/Checkpointer.hpp"
#include "checkpointing/CheckpointerDataInterface.hpp"
#include "columns/Messages.hpp"
#include "include/pv_common.h"
#include "observerpattern/Observer.hpp"
#include "utils/PVAlloc.hpp"
#include "utils/PVAssert.hpp"
#include "utils/PVLog.hpp"
#include <memory>

#ifdef PV_USE_CUDA
#include "arch/cuda/CudaDevice.hpp"
#endif // PV_USE_CUDA

namespace PV {

class HyPerCol;

class BaseObject : public CheckpointerDataInterface {
  public:
   inline char const *getName() const { return name; }
   // No getParent method because we are refactoring away from having objects
   // having access to their containing HyPerCol.

   inline std::string const &getObjectType() const { return mObjectType; }

   char const *lookupKeyword() const;

   void readParams() { ioParams(PARAMS_IO_READ, false, false); }

   void writeParams() { ioParams(PARAMS_IO_WRITE, true, true); }

   void ioParams(enum ParamsIOFlag ioFlag, bool printHeader, bool printFooter);

   virtual Response::Status respond(std::shared_ptr<BaseMessage const> message) override;
   // TODO: should return enum with values corresponding to PV_SUCCESS, PV_FAILURE, PV_POSTPONE

   virtual ~BaseObject();

   bool getInitInfoCommunicatedFlag() const { return mInitInfoCommunicatedFlag; }

   bool getDataStructuresAllocatedFlag() const { return mDataStructuresAllocatedFlag; }

   bool getInitialValuesSetFlag() const { return mInitialValuesSetFlag; }

#ifdef PV_USE_CUDA

   bool isUsingGPU() const { return mUsingGPUFlag; }
#endif // PV_USE_CUDA

  protected:
   BaseObject();
   int initialize(char const *name, HyPerCol *hc);
   int setName(char const *name);
   int setParent(HyPerCol *hc);
   virtual void setObjectType();
   void setDescription();

   virtual int ioParamsFillGroup(enum ParamsIOFlag ioFlag) { return PV_SUCCESS; }

   Response::Status
   respondCommunicateInitInfo(std::shared_ptr<CommunicateInitInfoMessage const> message);
#ifdef PV_USE_CUDA
   Response::Status respondSetCudaDevice(std::shared_ptr<SetCudaDeviceMessage const> message);
#endif // PV_USE_CUDA
   Response::Status respondAllocateData(std::shared_ptr<AllocateDataMessage const> message);
   Response::Status respondInitializeState(std::shared_ptr<InitializeStateMessage const> message);
   Response::Status
   respondCopyInitialStateToGPU(std::shared_ptr<CopyInitialStateToGPUMessage const> message);
   Response::Status respondCleanup(std::shared_ptr<CleanupMessage const> message);

   virtual Response::Status
   communicateInitInfo(std::shared_ptr<CommunicateInitInfoMessage const> message) {
      return Response::SUCCESS;
   }
#ifdef PV_USE_CUDA
   virtual Response::Status setCudaDevice(std::shared_ptr<SetCudaDeviceMessage const> message);
#endif // PV_USE_CUDA
   virtual Response::Status allocateDataStructures() { return Response::NO_ACTION; }
   virtual Response::Status initializeState() { return Response::NO_ACTION; }
   virtual Response::Status readStateFromCheckpoint(Checkpointer *checkpointer) override {
      return Response::NO_ACTION;
   }
   virtual Response::Status copyInitialStateToGPU() { return Response::SUCCESS; }
   virtual Response::Status cleanup() { return Response::NO_ACTION; }

   void setInitInfoCommunicatedFlag() { mInitInfoCommunicatedFlag = true; }

   void setDataStructuresAllocatedFlag() { mDataStructuresAllocatedFlag = true; }

   void setInitialValuesSetFlag() { mInitialValuesSetFlag = true; }

   // Data members
  protected:
   char *name = nullptr;
   std::string mObjectType;
   // TODO: eliminate HyPerCol argument to constructor in favor of PVParams argument
   HyPerCol *parent                  = nullptr;
   bool mInitInfoCommunicatedFlag    = false;
   bool mDataStructuresAllocatedFlag = false;
   bool mInitialValuesSetFlag        = false;
#ifdef PV_USE_CUDA
   bool mUsingGPUFlag              = false;
   PVCuda::CudaDevice *mCudaDevice = nullptr;
#endif // PV_USE_CUDA

  private:
   int initialize_base();
}; // class BaseObject

} // namespace PV

#endif /* BASEOBJECT_HPP_ */