WsfStableOrderEventManager.hpp

Go to the documentation of this file.

// ****************************************************************************
// CUI
//
// The Advanced Framework for Simulation, Integration, and Modeling (AFSIM)
//
// Copyright 2003-2015 The Boeing Company. All rights reserved.
//
// The use, dissemination or disclosure of data in this file is subject to
// limitation or restriction. See accompanying README and LICENSE for details.
// ****************************************************************************
 
#ifndef WSFSTABLEORDEREVENTMANAGER_HPP
#define WSFSTABLEORDEREVENTMANAGER_HPP
 
#include "wsf_export.h"
 
#include <mutex>
#include <queue>
#include <vector>
 
#include "WsfEventManager.hpp"
 
class WsfEvent;

class WSF_EXPORT WsfStableOrderEventManager : public WsfEventManager
{
public:
   WsfStableOrderEventManager()
      : WsfEventManager()
      , mStableEvents()
   {
   }
 
   virtual ~WsfStableOrderEventManager() { Reset(); }
 
   typedef std::pair<WsfEvent*, unsigned int> StableEvent;

   virtual void AddEvent(WsfEvent* aEventPtr)
   {
      mMutex.lock();
      mStableEvents.push(std::make_pair<WsfEvent*, unsigned int>(aEventPtr, mNextCount++));
      mMutex.unlock();
   }

   virtual WsfEvent* PeekEvent()
   {
      WsfEvent* eventPtr = 0;
      if (!mStableEvents.empty())
      {
         mMutex.lock();
         eventPtr = mStableEvents.top().first;
         mMutex.unlock();
      }
      return eventPtr;
   }

   virtual WsfEvent* PopEvent()
   {
      WsfEvent* eventPtr = 0;
      if (!mStableEvents.empty())
      {
         mMutex.lock();
         eventPtr = mStableEvents.top().first;
         mStableEvents.pop();
         mMutex.unlock();
      }
      return eventPtr;
   }

   virtual void Reset()
   {
      mMutex.lock();
      while (!mStableEvents.empty())
      {
         WsfEvent* eventPtr = mStableEvents.top().first;
         mStableEvents.pop();
         delete eventPtr;
      }
      mMutex.unlock();
      mNextCount = 0;
   }
 
private:
   WsfStableOrderEventManager(const WsfStableOrderEventManager& aSrc);

   WsfStableOrderEventManager& operator=(const WsfStableOrderEventManager& aRhs) = delete;

 
   class StableCompare
   {
   public:
      StableCompare()
         : mDummy(0)
      {
      }
      bool operator()(StableEvent aLhs, StableEvent aRhs) const
      {
         if (aLhs.first->GetTime() > aRhs.first->GetTime())
         {
            return true;
         }
         else if (aLhs.first->GetTime() < aRhs.first->GetTime())
         {
            return false;
         }
         else
         {
            return (aLhs.second > aRhs.second);
         }
      }
 
   private:
      int mDummy;
   };
 
   // std::priority_queue<WsfEvent*, std::vector<WsfEvent*>, StableCompare>    mEvents;
   // std::recursive_mutex mMutex;
 
   std::priority_queue<StableEvent, std::vector<StableEvent>, StableCompare> mStableEvents;
   static unsigned int                                                       mNextCount;
};
 
unsigned int WsfStableOrderEventManager::mNextCount = 0;
 
#endif