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 DtSimManager;
class DtSimMessage;
class DtVrfObject;

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

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

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 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&);

   virtual const DtRwScenarioEvent& scenarioEvent(const DtVrfObject*);

   virtual double simulationStartTime(const DtUUID&) const;

   virtual double simulationEndTime(const DtUUID&) const;

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

   static void scenarioEventRemoved(const DtVrfObject*, void*);
   virtual void processScenarioEventRemoved(const 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<const DtVrfObject*, EventUpdateInformation> EventsThatNeedUpdate;

   const EventsThatNeedUpdate& eventsThatNeedUpdate() const
   {
      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;

   static void vrfObjectModifiedViaMessageCallback(const DtVrfObject* o, void*);
   virtual void processObjectModifiedViaMessage(const DtVrfObject* o);

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

protected:
   DtSimManager* mySimManager;

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

   typedef DtCallbackList<DtEnableStateChanged> ScenarioEventEnableStateChangedCallbacks;
   ScenarioEventEnableStateChangedCallbacks myScenarioEventEnabledStateChangedCallbacks;

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

      const DtVrfObject* 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;
};