WsfCommQueue.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 WSFCOMMQUEUE_HPP
#define WSFCOMMQUEUE_HPP
 
#include "wsf_export.h"
 
#include <limits>
#include <list>
#include <memory>
#include <vector>
 
#include "UtCloneablePtr.hpp"
#include "WsfCommMessage.hpp"
 
namespace wsf
{
namespace comm
{

class WSF_EXPORT Queue
{
public:
   enum class QueueType : size_t
   {
      cFIFO,    // First-in-first-out
      cLIFO,    // Last-in-last-out
      cPRIORITY // Assigned priority queue
   };
 
   class Entry
   {
   public:
      enum class EntryStatus : size_t
      {
         cQUEUED,     // Initial push to queue. No other action taken.
         cPROCESSED,  // Popped. Awaiting feedback. Ignored during subsequent pops.
         cREPROCESSED // A special status similar to cPROCESSED. For datalink layer usage,
                      // indicates a message is scheduled for retransmission, but not eligible
                      // for typical queue processing.
      };
 
      Entry()                  = default;
      virtual ~Entry()         = default;
      Entry(const Entry& aSrc) = default;
 
      bool   operator==(const Entry& aRhs) const;
      Entry& operator=(const Entry& aRhs) = default;
 
      double      GetQueueTime() const { return mQueueTime; }
      void        SetQueueTime(double aSimTime) { mQueueTime = aSimTime; }
      Message*    GetMessage() const { return mMessage.get(); }
      void        SetMessage(Message* aMessagePtr);
      EntryStatus GetStatus() const { return mStatus; }
      void        SetStatus(EntryStatus aStatus) { mStatus = aStatus; }
 
      size_t GetCounter() const { return mCounter; }
      void   SetCounter(size_t aCount) { mCounter = aCount; }
      void   IncrementCounter() { ++mCounter; }
      void   DecrementCounter() { --mCounter; }
      void   ResetCounter() { mCounter = 0; }
 
   private:
      double                    mQueueTime{0.0};
      ut::CloneablePtr<Message> mMessage{nullptr};
      size_t                    mCounter{0};
      EntryStatus               mStatus{EntryStatus::cQUEUED};
   };
 
   Queue()          = default;
   virtual ~Queue() = default;
 
   bool Push(const Entry& aEntry);

   void Pop();

   const Entry& Top() const;
 
   const Entry* Peek(const Message::Identifier& aIdentifier) const;
   Entry*       Peek(const Message::Identifier& aIdentifier);

   size_t Size() const { return mQueue.size(); }

   size_t SizeActiveEntries() const;

   bool Empty() const { return mQueue.empty(); }

   bool EmptyActiveEntries() const;
 
   QueueType GetQueueType() const { return mQueueType; }
   void      SetQueueType(QueueType aType) { mQueueType = aType; }


   size_t GetLimit() const { return mLimit; }
   void   SetLimit(size_t aLimit) { mLimit = aLimit; }
 
   std::vector<Entry> Remove(double aTime);



   bool EntryProcessed(const Message::Identifier& aIdentifier);

   bool EntryReprocessed(double aSimTime, const Message::Identifier& aIdentifier);

   bool EntryDropped(const Message::Identifier& aIdentifier);
 
private:
   QueueType        mQueueType{QueueType::cFIFO};
   size_t           mLimit{std::numeric_limits<size_t>::max()};
   std::list<Entry> mQueue{};
};
 
} // namespace comm
} // namespace wsf
 
#endif