scenarioEventManager.h

Go to the documentation of this file.

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

#pragma once

#include "vrfobjcore/vrfobjcoreDefines.h"
#include <vrfutil/rwScenarioEvent.h>
#include <readerWriter/noArgumentCallbackList.h>
#include <vrfutil/rwUUID.h>
#include <boost/unordered_map.hpp>

class DtSimulationServices;
class DtSimMessage;
class DtLocalObject;
class DtLocalObjectManager;

typedef DtCallbackList<const DtUUID&>::DtCallbackFunctionType DtScenarioEventManagerCallbackFcn;

struct DtEnableStateChanged
{
   DtUUID uuid;
   bool isEnabled;
};
typedef DtCallbackList<DtEnableStateChanged>::DtCallbackFunctionType DtScenarioEventManagerEnabledStateChangedCallbackFcn;

class DT_DLL_vrfobjcore DtScenarioEventManager
{
public:
   DtScenarioEventManager(DtSimulationServices*, DtLocalObjectManager*);

   virtual ~DtScenarioEventManager();

private:
   DtScenarioEventManager(const DtScenarioEventManager & orig);

   DtScenarioEventManager & operator=(const DtScenarioEventManager & orig);

public:
   virtual bool isScenarioEvent(const DtUUID& o) const;


   virtual void addScenarioEventStartedCallback(DtScenarioEventManagerCallbackFcn fcn, void* usr);
   virtual void removeScenarioEventStartedCallback(DtScenarioEventManagerCallbackFcn fcn, void* usr);


   virtual void addScenarioEventEnabledStateChangedCallback(DtScenarioEventManagerEnabledStateChangedCallbackFcn fcn, void* usr);
   virtual void removeScenarioEventEnabledStateChangedCallback(DtScenarioEventManagerEnabledStateChangedCallbackFcn fcn, void* usr);


   virtual void addScenarioEventStoppedCallback(DtScenarioEventManagerCallbackFcn fcn, void* usr);
   virtual void removeScenarioEventStoppedCallback(DtScenarioEventManagerCallbackFcn fcn, void* usr);

   static void scenarioEventMessageCallback(DtSimMessage*, void* usr);
   virtual void processScenarioEventMessageCallback(DtSimMessage*);

   virtual void setScenarioEventEnabled(const DtUUID&, bool, bool sendMessageIfNotLocal = true);

   virtual bool scenarioEventIsEnabled(const DtUUID&);

   virtual void startScenarioEvent(const DtUUID&, bool sendMessageIfNotLocal = true);

   virtual void stopScenarioEvent(const DtUUID&, bool sendMessageIfNotLocal = true);

   virtual bool scenarioEventInProgress(const DtUUID&) const;

   virtual bool scenarioEventIsConcluded(const DtUUID&) const;

   virtual bool scenarioEventConcluded(const DtUUID&) const;

   virtual const DtRwScenarioEvent& scenarioEvent(const DtUUID&) const;

   virtual double simulationStartTime(const DtUUID&) const;

   virtual double simulationEndTime(const DtUUID&) const;

   static void scenarioEventAdded(const DtLocalObject*, void*);
   virtual void processScenarioEventAdded(const DtLocalObject*);

   static void scenarioEventRemoved(const DtLocalObject*, void*);
   virtual void processScenarioEventRemoved(const DtLocalObject*);

   virtual void setOrdinalOrder(const DtUUID& uniqueId, int ordinal);

   virtual void resetScenarioEvent(const DtUUID& uniqueId, bool sendMessageIfNotLocal = true);

   virtual void setTriggerStatus(const DtUUID& uniqueId, int);

   virtual void merge(DtScenarioEventManager*, const DtString& deconflictingName);

   struct EventUpdateInformation
   {
      DtRwScenarioEvent* scenarioEvent;
      DtRwScenarioEvent::PredecessorList linkList;
   };

   typedef std::map<const DtLocalObject*, EventUpdateInformation> EventsThatNeedUpdate;

   const EventsThatNeedUpdate& eventsThatNeedUpdate() const
   {
      return myEventsThatNeedUpdate;
   }

   EventsThatNeedUpdate& eventsThatNeedUpdate()
   {
      return myEventsThatNeedUpdate;
   }

protected:
   virtual void startUpEvent(const DtUUID& uniqueId);

   virtual void stopEvent(const DtUUID& uniqueId);

   virtual void updateEnabledStatesLinkedTo(const DtUUID&);

   virtual DtUUID scenarioEventUUIDBasedOf(const DtUUID&) const;

   virtual void processObjectModifiedViaMessage(DtLocalObject* o);

   virtual bool isThisObjectLinkedToMe(const DtUUID& source, const DtUUID& dest) const;

protected:
   DtSimulationServices* mySimulationServices;
   DtLocalObjectManager* myObjectManager;

   typedef DtCallbackList<const DtUUID&> ScenarioEventCallbacks;
   ScenarioEventCallbacks myScenarioEventStartedCallbacks;
   ScenarioEventCallbacks myScenarioEventStoppedCallbacks;

   typedef DtCallbackList<DtEnableStateChanged> ScenarioEventEnableStateChangedCallbacks;
   ScenarioEventEnableStateChangedCallbacks myScenarioEventEnabledStateChangedCallbacks;

   struct ScenarioEventInformation
   {
      ScenarioEventInformation() : scenarioEvent(0), rwEvent(""), curLinkedTo(DtUUID::nullUUID()) {};

      DtLocalObject* scenarioEvent;
      DtRwScenarioEvent rwEvent;
      DtString rwData;
      DtUUID curLinkedTo;
   };

   typedef std::map<DtUUID, ScenarioEventInformation> ScenarioEvents;
   ScenarioEvents myScenarioEvents;

   typedef std::map<DtUUID, DtUUID> ObjectEvents;
   ObjectEvents myObjectEvents;

   EventsThatNeedUpdate myEventsThatNeedUpdate;

   int myMaxOrdinal;
};