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 <vrfutil/noArgumentCallbackList.h>
#include <vrfutil/rwUUID.h>
#include <boost/unordered_map.hpp>

class DtSimManager;
class DtSimMessage;
class DtVrfObject;

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

class DT_DLL_vrfobjcore DtScenarioEventManager
{
public:
   DtScenarioEventManager(DtSimManager*);

   virtual ~DtScenarioEventManager();

private:
   DtScenarioEventManager(const DtScenarioEventManager & orig);

   DtScenarioEventManager & operator=(const DtScenarioEventManager & orig);

public:
   virtual DtSimManager* simManager() const;

   virtual bool isScenarioEvent(const DtVrfObject* o) const;


   virtual void addScenarioEventStartedCallback(DtScenarioEventManagerCallbackFcn fcn, void* usr);
   virtual void removeScenarioEventStartedCallback(DtScenarioEventManagerCallbackFcn 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 startScenarioEvent(const DtUUID&, bool sendMessageIfNotLocal = true);

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

   virtual bool scenarioEventInProgress(const DtUUID&) const;

   virtual bool scenarioEventConcluded(const DtUUID&) const;

   virtual DtRwScenarioEvent scenarioEvent(const DtUUID&);

   virtual DtRwScenarioEvent scenarioEvent(const DtVrfObject*);

   virtual double simulationStartTime(const DtUUID&) const;

   virtual double simulationEndTime(const DtUUID&) const;

   static void scenarioEventAdded(DtVrfObject*, void*);
   virtual void processScenarioEventAdded(DtVrfObject*);

   static void scenarioEventRemoved(DtVrfObject*, void*);
   virtual void processScenarioEventRemoved(DtVrfObject*);

   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<DtVrfObject*, EventUpdateInformation> EventsThatNeedUpdate;

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

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

   virtual void stopEvent(const DtUUID& uniqueId);

protected:
   DtSimManager* mySimManager;

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

   struct ScenarioEventInformation
   {
      ScenarioEventInformation() : scenarioEvent(0), triggerStatus(-1),
         simTimeStarted(0.), simTimeEnded(0.), rwEvent("") {};

      DtVrfObject* scenarioEvent;
      int triggerStatus;
      double simTimeStarted;
      double simTimeEnded;
      DtRwScenarioEvent rwEvent;
      DtString rwData;
   };

   typedef boost::unordered_map<DtUUID, ScenarioEventInformation> ScenarioEvents;
   ScenarioEvents myScenarioEvents;

   typedef boost::unordered_map<DtUUID, DtUUID> ObjectEvents;
   ObjectEvents myObjectEvents;

   EventsThatNeedUpdate myEventsThatNeedUpdate;

   int myMaxOrdinal;
};