msgQueue.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 2001 MaK Technologies, Inc.
** All rights reserved.
*********************************************************************/
/*********************************************************************
** $RCSfile: msgQueue.h,v $ $Revision: 1.20 $ $State: Exp $
*********************************************************************/


#ifndef DtRtiMsgQueue_H_
#define DtRtiMsgQueue_H_

#include <rtiMsConfig.h>
#include <internalTypes.h>
#include <sortedList.h>
#include <rtiApiTypes.h>

#include <vlutil/vlHashlist.h>
#include <memory>

class DtRtiMsg;
class DtLogicalTimeFactory;
class DtInteractionMgr;
class DtObjectMgr;

class DT_DLL_LRC DtMessageItem : public DtSortedListItem
{
public:

   friend class DtRtiMsgQueue;

public:

   virtual ~DtMessageItem();

   virtual bool operator<= (const DtSortedListItem& item) const;
   virtual bool operator<  (const DtSortedListItem& item) const;
   virtual bool operator>= (const DtSortedListItem& item) const;
   virtual bool operator>  (const DtSortedListItem& item) const;
   virtual bool operator== (const DtSortedListItem& item) const;

   virtual void printData(DtLogicalTimeFactory* logicalTimeFactory);

   virtual DtRtiMsg* msg();

protected:

   DtMessageItem(void* data, DtLogicalTimeFactory* fedTimeFactory);

protected:
   DtRtiMsg* myMsg;
   DtLogicalTimeFactory* myLogicalTimeFactory;
};

inline DtRtiMsg* DtMessageItem::msg()
{
   return myMsg;
}


class DT_DLL_LRC DtRtiMsgQueue : public DtSortedList
{

public:
   DtRtiMsgQueue(DtLogicalTimeFactory* fedTimeFactory, DtObjectMgr* objMgr=0, DtInteractionMgr* intMgr=0);

   virtual ~DtRtiMsgQueue();

   virtual bool timeRegulating();
   virtual void setTimeRegulating(bool isTimeRegulating);
   virtual bool timeConstrained();
   virtual void setTimeConstrained(bool isTimeConstrained);
   virtual bool asynchronous();
   virtual void setAsynchronous(bool isAsynchronous);
   virtual bool timeAvailable();
   virtual void setTimeAvailable(bool isTimeAvailable);
   virtual bool timeAdvancing();
   virtual void setTimeAdvancing(bool isTimeAdvancing);

   virtual const DtRtiApiTime& timestamp();
   virtual void setTimestamp(const DtRtiApiTime& federateTime);

   virtual const DtRtiApiTimeInterval& lookahead();
   virtual void setLookahead(const DtRtiApiTimeInterval& lookaheadValue);

   virtual const DtRtiApiTime& galt();
   virtual void setGalt(const DtRtiApiTime& federateTime);

   virtual bool queueMsg(DtRtiMsg const& msg);

   virtual void restoreMsg(DtRtiMsg const& msg);

   virtual DtRtiMsg* removeMsg(const DtMessageRetractionHandle& retractHandle);

   virtual bool deleteMsg(const DtMessageRetractionHandle& retractHandle);

   virtual void deleteMsgs(DtFederateHandle federateHandle);

   virtual void deleteAll();

   virtual DtRtiMsg* nextMsg(const DtRtiApiTime& timestamp);

   virtual DtRtiMsg* nextTsoMsg(const DtRtiApiTime& timestamp);

   virtual DtRtiMsg* removeNextTsoMsg();

   virtual DtRtiMsg* peekNextTsoMsg();

   inline unsigned int roQueueLength() const;

   virtual void clean();

   virtual bool isDirty() const;

protected:

   virtual DtSortedListItem* newItem(void* data);

   DtRtiMsgQueue(const DtRtiMsgQueue& orig);
   DtRtiMsgQueue& operator=(DtRtiMsgQueue const& orig);

   virtual DtSortedListItem* add(void* data);

   virtual int evaluateSubscription(DtRtiMsg const& msg);
   
protected:

   MAKRti::DtList myRoList;
   bool myTimeConstrainedEnabled;
   bool myTimeRegulatingEnabled;
   bool myAsynchronous;
   bool myTimeAvailable;
   bool myTimeAdvancing;
   bool myIsDirty;
   DtLogicalTimeFactory* myLogicalTimeFactory;
   DtObjectMgr* myObjMgr;
   DtInteractionMgr* myIntMgr;
   DtRtiApiUniquePtr<DtRtiApiTime> myTime;
   DtRtiApiUniquePtr<DtRtiApiTimeInterval> myLookahead;
   DtRtiApiUniquePtr<DtRtiApiTime> myGalt;
};

inline bool DtRtiMsgQueue::timeRegulating()
{
   return myTimeRegulatingEnabled;
}

inline void DtRtiMsgQueue::setTimeRegulating(bool isTimeRegulating)
{
   myTimeRegulatingEnabled = isTimeRegulating;
}

inline bool DtRtiMsgQueue::timeConstrained()
{
   return myTimeConstrainedEnabled;
}

inline void DtRtiMsgQueue::setTimeConstrained(bool isTimeConstrained)
{
   myTimeConstrainedEnabled = isTimeConstrained;
}

inline bool DtRtiMsgQueue::asynchronous()
{
   return myAsynchronous;
}

inline void DtRtiMsgQueue::setAsynchronous(bool isAsynchronous)
{
   myAsynchronous = isAsynchronous;
}

inline bool DtRtiMsgQueue::timeAvailable()
{
   return myTimeAvailable;
}

inline void DtRtiMsgQueue::setTimeAvailable(bool isTimeAvailable)
{
   myTimeAvailable = isTimeAvailable;
}

inline bool DtRtiMsgQueue::timeAdvancing()
{
   return myTimeAdvancing;
}

inline void DtRtiMsgQueue::setTimeAdvancing(bool isTimeAdvancing)
{
   myTimeAdvancing = isTimeAdvancing;
}

inline const DtRtiApiTime& DtRtiMsgQueue::timestamp()
{
   return *myTime;
}

inline void DtRtiMsgQueue::setTimestamp(const DtRtiApiTime& federateTime)
{
   *myTime = federateTime;
}

inline const DtRtiApiTimeInterval& DtRtiMsgQueue::lookahead()
{
   return *myLookahead;
}

inline void DtRtiMsgQueue::setLookahead(const DtRtiApiTimeInterval& lookaheadValue)
{
   *myLookahead = lookaheadValue;
}

inline const DtRtiApiTime& DtRtiMsgQueue::galt()
{
   return *myGalt;
}

inline void DtRtiMsgQueue::setGalt(const DtRtiApiTime& federateTime)
{
   *myGalt = federateTime;
}

inline unsigned int DtRtiMsgQueue::roQueueLength() const
{
   return myRoList.count();
}

#endif