simComponent.h

Go to the documentation of this file.

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

#pragma once



#include <vlutil/vlString.h>
#include <vlutil/vlList.h>
#include <readerWriter/readerWriter.h>
#include "vrfobjcore/simComponentFactory.h"
#include "vrfobjcore/vrfObjectStateRepository.h"
#include <vlutil/vlHashlist.h>
#include "vrfobjcore/vrfobjcoreDefines.h"
#include "vrfcore/parallelTickManager.h"
#include "vrfobjcore/taskVisualization.h"
#include "vrfobjcore/pointTaskVisualization.h"
#include "vrfobjcore/lineTaskVisualization.h"
#include "vrfobjcore/areaTaskVisualization.h"
#include "vrfobjcore/textTaskVisualization.h"
#include <list>

class DtSimManager;
class DtVrfObject;
class DtComponentDescriptor;
class DtInputPort;
class DtOutputPort;
class DtInputPortGroup;
class DtOutputPortGroup;
class DtAttachedTerrain;
class DtPhysicalWorld;
class Coordinate_System;
class DtComponentSystem;
class DtVrfProcessStateRepositoryManager;
class DtSimResourceManager;
class DtCriticalSection;
class DtVrfProcessStateRepository;

class DT_DLL_vrfobjcore DtSimComponent : public DtReaderWriter
   , public DtObjectDebugger<DtSimComponent>
{
public:

   class DT_DLL_vrfobjcore ComponentCriticalSection
   {
   public:
      explicit ComponentCriticalSection(
         DtSimComponent&, DtParallelTickManager::AccessType);

      explicit ComponentCriticalSection(
         ComponentCriticalSection&, DtParallelTickManager::AccessType);

      explicit ComponentCriticalSection(DtSimComponent&);

      explicit ComponentCriticalSection(ComponentCriticalSection&);

      void reset(DtParallelTickManager::AccessType access);

      void unlock();

      void lockShared();

      void lock();

   private:
      bool myThreadSafe;
      DtCriticalSection myCriticalSection;
   };

   static DtSimComponent* MarkThreadSafe(DtSimComponent*);

   DtSimComponent(const DtString& name, 
      DtVrfObject* owner, 
      DtSimManager* simManager, 
      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(DtVrfObject* 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;

   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, DtVrfObject* owner, DtSimManager* simManager, 
      DtComponentSystem* parentSystem,
      DtComponentDescriptor* desc = 0, 
      DtReaderWriterRegistry* parentRegistry = 0);

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

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

   DtAttachedTerrain* terrainAttachedTo();
   const DtAttachedTerrain* terrainAttachedTo() const;

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

   const DtVrfObject* const_entity() const { return myEntity; }

   DtSimManager* simManager() { return mySimManager; }
   const DtSimManager* simManager() const { return mySimManager; }

   const Coordinate_System* coordinateSystem() const;

   DtVrfObjectStateRepository* localStateRepository();
   const DtVrfObjectStateRepository* localStateRepository() const;

   const DtVrfObjectStateRepository* const_localStateRepository() const;

   virtual DtTaskVisualizationMap& taskVisualizations();

   virtual bool taskVisualizationsActive() const;

   virtual bool taskVisualizationsEnabled() const;

   virtual bool isThreadSafe() const;

   virtual void addVRLinkDeferredJob(const boost::function<void()>& callback);

   virtual void onRestore();

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 DtPointTaskVisualizationPtr pointTaskVisualization(const DtString& name);

   virtual DtLineTaskVisualizationPtr lineTaskVisualization(const DtString& name);

   virtual DtAreaTaskVisualizationPtr areaTaskVisualization(const DtString& name);

   virtual DtTextTaskVisualizationPtr textTaskVisualization(const DtString& name);

   double calculateNextTaskVisTickTime() const;

private:
   DtSimComponent();

   DtSimComponent(const DtSimComponent& orig);

   DtSimComponent& operator=(const DtSimComponent& orig);


protected:
   DtVrfObject*                  myEntity;
   DtVrfObjectStateRepository*   myLocalStateRepository;
   DtSimManager*                 mySimManager;
   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;

   bool myIsThreadSafe;

   const DtComponentDescriptor* myComponentDescriptor;

   std::list<DtVrfProcessStateRepository*> myComponentPsrs;

   bool myTickEveryFrame;

   DtTaskVisualizationMap myTaskVisualizations;

   double myNextTaskVisTickTime;

   mutable DtSymbolString myFullComponentName;
};

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

DT_DEFINE_OBJECT_DEBUGGER_NAME(DtSimComponent);