WsfTimeDelayQueue.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 WSFTIMEDELAYQUEUE_HPP
#define WSFTIMEDELAYQUEUE_HPP
 
#include "wsf_export.h"
 
#include <list>
#include <queue>
#include <stack>
#include <vector>
 
class UtInput;
#include "WsfEvent.hpp"
class WsfPlatform;
class WsfPlatformPart;
class WsfScriptContext;
#include "WsfVariable.hpp"

class WSF_EXPORT WsfTimeDelayQueue
{
public:
   enum QueuingMethod
   {
      cFIRST_IN_FIRST_OUT, 
      cLAST_IN_FIRST_OUT,  
      cPRIORITY,           
      cNONE                
   };

   class Request
   {
   public:
      Request(double aTimeRequired)
         : mTimeRequired(aTimeRequired)
      {
      }
      virtual ~Request() = default;

      virtual bool CompleteRequest(double aSimTime) = 0;

      double TimeRequired() const { return mTimeRequired; }

      void SetTimeRequired(double aTimeRequired) { mTimeRequired = aTimeRequired; }
 
   private:
      double mTimeRequired{0.0};
   };
 
   WsfTimeDelayQueue() = default;
   WsfTimeDelayQueue(const WsfTimeDelayQueue& aSrc);
   WsfTimeDelayQueue& operator=(const WsfTimeDelayQueue&) = delete;
   virtual ~WsfTimeDelayQueue();


   virtual WsfTimeDelayQueue* Clone() const;
 
   virtual bool Initialize(double            aSimTime,
                           WsfPlatform*      aPlatformPtr,
                           WsfPlatformPart*  aPlatformPartPtr,
                           WsfScriptContext* aContextPtr);
 
   virtual bool ProcessInput(UtInput& aInput);
 
   virtual void TurnOff(double aSimTime);
 
   virtual void TurnOn(double aSimTime);
 
   void SetNumberOfServers(int aNumberOfServers);
 
   virtual void SubmitRequest(double aSimTime, Request* aRequestPtr);


   virtual Request* CompleteRequest(double aSimTime, Request* aRequestPtr, size_t aServerIndex);

   unsigned int GetEventEpoch() const { return mEventEpoch; }

   WsfPlatform* GetPlatform() const { return mPlatformPtr; }

   class RequestQueue
   {
   public:
      RequestQueue()          = default;
      virtual ~RequestQueue() = default;
 
      virtual void     Purge()                    = 0;
      virtual void     Push(Request* aRequestPtr) = 0;
      virtual Request* Pop()                      = 0;
   };

   class FIFO_Queue : public WsfTimeDelayQueue::RequestQueue
   {
   public:
      void     Purge() override;
      void     Push(Request* aRequestPtr) override;
      Request* Pop() override;
 
   private:
      std::deque<Request*> mQueue;
   };

   class LIFO_Queue : public WsfTimeDelayQueue::RequestQueue
   {
   public:
      void     Purge() override;
      void     Push(Request* aRequestPtr) override;
      Request* Pop() override;
 
   private:
      std::deque<Request*> mQueue;
   };

   class PriorityQueue : public WsfTimeDelayQueue::RequestQueue
   {
   public:
      void     Purge() override;
      void     Push(Request* aRequestPtr) override;
      Request* Pop() override;
 
   private:
      std::priority_queue<Request*> mQueue;
   };

   class CompleteRequestEvent : public WsfEvent
   {
   public:
      CompleteRequestEvent() = default;
      CompleteRequestEvent(double aSimTime, Request* aRequestPtr, WsfTimeDelayQueue* aQueuePtr, size_t aServerIndex);
 
      ~CompleteRequestEvent() override;
 
      EventDisposition Execute() override;
 
   private:
      Request*           mRequestPtr{nullptr};
      WsfTimeDelayQueue* mQueuePtr{nullptr};
      size_t             mServerIndex{0};
      size_t             mPlatformIndex{0};
      unsigned int       mEventEpoch{0};
   };
 
   WsfSimulation* GetSimulation() const;
 
protected:
   void CleanUp();

   WsfPlatform* mPlatformPtr{nullptr};

   WsfVariable<int> mNumberOfServers{1};

   std::vector<Request*> mServers;

   QueuingMethod mQueuingMethod{cFIRST_IN_FIRST_OUT};

   RequestQueue* mPendingQueuePtr{nullptr};

   unsigned int mEventEpoch{1};
};
 
#endif