simComponent.h

Go to the documentation of this file.

/****************************************************************************
 * Copyright (c) 2022 MAK Technologies, Inc.
 * All rights reserved.
 ****************************************************************************/


#pragma once

#include <vrfobjcore/vrfobjcoreDefines.h>
#include <vrfobjcore/predicateCallbackManager.h>
#include <vrfobjcore/simComponentFactory.h>
#include <vrfobjcore/localObject.h>
#include <vrfobjcore/attachedTerrain.h>

#include <vrfStateData/taskVisualizationForwards.h>
#include <vrfcore/simulationServices.h>
#include <readerWriter/readerWriter.h>

//#include <vrfutil/objectConsole.h>
#include <vrfutil/vrf4XAPI.h>

#include <boost/shared_ptr.hpp>

#include <vlutil/vlHashlist.h>
#include <vlutil/vlString.h>
#include <vlutil/vlList.h>

#include <list>

class DtComponentDescriptor;
class DtInputPort;
class DtOutputPort;
class DtInputPortGroup;
class DtOutputPortGroup;
class DtPhysicalWorld;
class Coordinate_System;
class DtComponentSystem;
class DtVrfProcessStateRepositoryManager;
class DtSimResourceManager;
class DtVrfProcessStateRepository;
class DtLocalObject;
class DtSimObject;
class DtSimulationServices;
class DtSimMessage;
class DtAttachedTerrain;

class DT_DLL_vrfobjcore DtSimComponent : public DtReaderWriter
#ifdef DtObjectDebugger_Enable
   , public DtObjectDebugger<DtSimComponent>
#endif
{
public:

   DtSimComponent(const DtString& name,
      DtLocalObject* owner,
      DtSimulationServices* simServices,
      DtComponentDescriptor* desc = 0,
      DtReaderWriterRegistry* parentRegistry = 0);

   virtual ~DtSimComponent();

   virtual void setParentSystem(DtComponentSystem* system);
   DtComponentSystem * parentSystem() const;

   virtual bool init();

   virtual bool postAddComponentsInit() { return true; }

   virtual void registerAttributeFunctions(){}

   virtual void enable();
   virtual void disable();
   virtual bool isEnabled();
   virtual void setIsEnabled(bool yesNo);

   virtual void preFirstTickInit();

   virtual void tick();

   virtual void postTick();

   virtual void timedTick();

   virtual void setMinTickPeriod(double minTickPeriod);

   virtual double minTickPeriod() const;

   virtual void setMinTickPeriodVariance(double minTickPeriodVariance);

   virtual double minTickPeriodVariance() const;

   virtual void setNextTickTime(double nextTickTime);

   virtual double nextTickTime() const;

   virtual double calculateNextTickTime() const;

   virtual double calculateFirstTickTime() const;

   virtual const char* type() const = 0;

   virtual void setEntity(DtLocalObject* entity);

   virtual DtSimComponent* nextComponent();
   virtual DtSimComponent* prevComponent();

   virtual void setListItem(DtListItem* item);
   virtual DtListItem* listItem();

   virtual void putData(std::string& fp, int indentLevel = 0);

   virtual DtlObjPtr getData(DtlObjPtr args, const DtReaderWriter::SearchPaths& searchPaths,
      const DtVariableBindingsList& variableBindings);

   virtual void addInputPort(DtInputPort* port);
   virtual void removeInputPort(DtInputPort* port);

   virtual DtInputPort* lookupInputPort(const DtString& portName);

   virtual DtList inputPortList() const;

   virtual void addOutputPort(DtOutputPort* port);
   virtual void removeOutputPort(DtOutputPort* port);

   virtual DtOutputPort* lookupOutputPort(const DtString& portName);

   virtual DtList outputPortList() const;

   virtual void addInputPortGroup(DtInputPortGroup* group);
   virtual void removeInputPortGroup(DtInputPortGroup* group);

   virtual DtInputPortGroup* lookupInputPortGroup(const DtString& groupName);

   virtual DtList inputPortGroupList() const;

   virtual void addOutputPortGroup(DtOutputPortGroup* group);
   virtual void removeOutputPortGroup(DtOutputPortGroup* group);

   virtual DtOutputPortGroup* lookupOutputPortGroup(const DtString& groupName);

   virtual DtList outputPortGroupList() const;

   virtual int priority() const;
   virtual void setPriority(int priority);

   double dT() const;

   virtual void setDT(double deltaT);

   virtual void setComponentDescriptor(DtComponentDescriptor* componentDescriptor);
   virtual const DtComponentDescriptor* componentDescriptor() const;

   virtual bool tickWhileDestroyed() const;

   virtual DtOutputStream& objectConsoleDebug(const DtString& channel = "") const;
   virtual DtOutputStream& objectConsoleVerbose(const DtString& channel = "") const;
   virtual DtOutputStream& objectConsoleInfo(const DtString& channel = "") const;
   virtual DtOutputStream& objectConsoleWarn(const DtString& channel = "") const;
   virtual DtOutputStream& objectConsoleError(const DtString& channel = "") const;
   virtual int notifyLevel() const;

   DtVrfProcessStateRepositoryManager* psrManager();


   virtual DtSimResourceManager& resourceManager();
   virtual const DtSimResourceManager& resourceManager() const;

   virtual const DtSymbolString& componentFullName() const;

   static DtSimComponentFactory* factory();
   static void setFactory(DtSimComponentFactory* factory);

   static DtSimComponent* createComponent(const DtString& name,
      const DtString& type, DtLocalObject* owner, DtSimulationServices* simManager,      DtComponentSystem* parentSystem,
      DtComponentDescriptor* desc = 0,
      DtReaderWriterRegistry* parentRegistry = 0);

   static void addSimComponentCreatorFcn(const DtString& type,
      DtSimComponentCreatorFcn fcn);

   DtPhysicalWorld* physicalWorld();
   const DtPhysicalWorld* physicalWorld() const;

   const DtAttachedTerrain* terrainAttachedTo() const;

   DtLocalObject* entity() { return myEntity; }
   const DtLocalObject* entity() const { return myEntity; };

   DtSimulationServices* simulationServices();
   const DtSimulationServices* simulationServices() const;

   const Coordinate_System* coordinateSystem() const;

   virtual bool taskVisualizationsActive() const;

   virtual bool taskVisualizationsEnabled() const;

   virtual void onRestore();

   makVrf::DtTaskVisualizationMap& taskVisualizations()
   {
      return myTaskVisualizations;
   }

protected:

   virtual double computeCurrentTime();

   bool testInvariant() const;

   virtual bool createPortGroups();

   virtual bool createPorts();

   DtVrfProcessStateRepository* createComponentPsr(const DtString& defaultPsrType,
      const DtString& defaultPsrName, bool useDescriptorParams = true);

   virtual void updateTaskVisualizations() {};

   virtual void destroyTaskVisualizations();

   virtual void destroyTaskVisualization(const DtString& name);

   virtual makVrf::DtPointTaskVisualizationPtr pointTaskVisualization(const DtString& name);

   virtual makVrf::DtLineTaskVisualizationPtr lineTaskVisualization(const DtString& name);

   virtual makVrf::DtAreaTaskVisualizationPtr areaTaskVisualization(const DtString& name);

   virtual makVrf::DtTextTaskVisualizationPtr textTaskVisualization(const DtString& name);

   double calculateNextTaskVisTickTime() const;

   DtVrfObjectStateRepository* localStateRepository();

   const DtVrfObjectStateRepository* localStateRepository() const;


   void addSimObjectPredicateCallback(DtSimObjectReference,
      DtVrfObjectPredicateCallbackFunction function,
      const DtVrfObjectPredicate& predicate, DtTime evaluationPeriod = 0,
      void* userData = 0);
   void removeSimObjectPredicateCallback(const DtSimObject*,
      DtVrfObjectPredicateCallbackFunction function,
      const DtVrfObjectPredicate& predicate, DtTime evaluationPeriod = 0,
      void* userData = 0);

   void invokeSimObjectPredicateCallbacks();

   virtual void clearPredicateCallbacks();

private:
   DtSimComponent();

   DtSimComponent(const DtSimComponent& orig);

   DtSimComponent& operator=(const DtSimComponent& orig);

protected:
   DtLocalObject*                  myEntity;

   DtComponentSystem*            mySystem;
   DtListItem*                   myListItem;

   typedef std::map<DtString, DtInputPort*> DtInputPortMap;
   typedef std::map<DtString, DtOutputPort*> DtOutputPortMap;
   typedef std::map<DtString, DtInputPortGroup*> DtInputPortGroupMap;
   typedef std::map<DtString, DtOutputPortGroup*> DtOutputPortGroupMap;

   DtInputPortMap myInputPortList;
   DtOutputPortMap myOutputPortList;
   DtInputPortGroupMap myInputPortGroupList;
   DtOutputPortGroupMap myOutputPortGroupList;

   static DtSimComponentFactory* myFactory;

   int                           myPriority;

   double myMinTickPeriod;
   double myMinTickPeriodVariance;
   double myNextTickTime;
   double myLastTickSimTime;
   double myDT;

   bool myIsEnabled;

   bool myFirstTick;

   const DtComponentDescriptor* myComponentDescriptor;

   std::list<DtVrfProcessStateRepository*> myComponentPsrs;

   bool myTickEveryFrame;

   makVrf::DtTaskVisualizationMap myTaskVisualizations;

   double myNextTaskVisTickTime;

   mutable DtSymbolString myFullComponentName;

   DtSimulationServices* mySimServices;
   DtPredicateCallbackManager myPredicateCallbackManager;

public:

   VRF4API_METHOD const DtSimulationServices* simManager() const { return simulationServices(); };
   VRF4API_METHOD static DtSimComponent* MarkThreadSafe(DtSimComponent* comp) { return comp; };
};

inline double DtSimComponent::dT() const
{
   return myDT;
}

DT_DEFINE_OBJECT_DEBUGGER_NAME(DtSimComponent);