simCmpnt.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 "vrfutil/rdrWritr.h"
#include "vrfobjcore/compFactory.h"
#include "vrfobjcore/vrfObjSR.h"
#include <vlutil/vlHashlist.h>
#include "vrfobjcore/vrfobjcoreDefines.h"

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 DT_DLL_vrfobjcore DtSimComponent : public DtReaderWriter
{

public:

   DtSimComponent(const DtString& name, 
      DtVrfObject* owner, 
      DtSimManager* simManager, 
      DtComponentDescriptor* desc = 0,
      DtReaderWriterRegistry* parentRegistry = 0);

   virtual ~DtSimComponent();

   void setParentSystem(DtComponentSystem* system);

   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 DtString type() const;

   virtual void setEntity(DtVrfObject* entity);

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

   virtual void setListItem(DtListItem* item);
   virtual DtListItem* listItem();
 
   virtual void putData(FILE* fp, int indentLevel = 0);

   virtual DtlObjPtr getData(DtlObjPtr args, const DtFilename& searchPath,
      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;
   virtual DtOutputStream& objectConsoleVerbose() const;
   virtual DtOutputStream& objectConsoleInfo() const;
   virtual DtOutputStream& objectConsoleWarn() const;
   virtual DtOutputStream& objectConsoleError() const;

   DtVrfProcessStateRepositoryManager* psrManager();


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

   virtual DtString 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);

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

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

   virtual DtVrfObject* entity();
   virtual const DtVrfObject* entity() const;

   virtual DtSimManager* simManager();
   virtual const DtSimManager* simManager() const;

   virtual const Coordinate_System* coordinateSystem() const;
   virtual Coordinate_System* coordinateSystem();

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

protected:

   bool testInvariant() const;

   virtual bool createPortGroups();

   virtual bool createPorts();

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;

   const DtComponentDescriptor* myComponentDescriptor;
};

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