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 <vlutil/vlHashlist.h>
#include "sortedList.h"
#include <memory>

#if defined(DtIFSPEC1516) || defined(DtIFSPEC1516E)
#include <RTI/LogicalTime.h>
#include <RTI/LogicalTimeInterval.h>
#else
#ifdef DtIFSPEC13DLC
#include "RTI13.h"
#define RTI rti13
#else
#include "RTI.hh"
#endif
#endif

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

#ifdef DtIFSPEC1516
   virtual const rti1516::LogicalTime& timestamp();
   virtual void setTimestamp(const rti1516::LogicalTime& federateTime);

   virtual const rti1516::LogicalTimeInterval& lookahead();
   virtual void setLookahead(const rti1516::LogicalTimeInterval& lookaheadValue);

   virtual const rti1516::LogicalTime& galt();
   virtual void setGalt(const rti1516::LogicalTime& federateTime);

#elif defined(DtIFSPEC1516E)
   virtual const rti1516e::LogicalTime& timestamp();
   virtual void setTimestamp(const rti1516e::LogicalTime& federateTime);

   virtual const rti1516e::LogicalTimeInterval& lookahead();
   virtual void setLookahead(const rti1516e::LogicalTimeInterval& lookaheadValue);

   virtual const rti1516e::LogicalTime& galt();
   virtual void setGalt(const rti1516e::LogicalTime& federateTime);
#else
   virtual const RTI::FedTime& timestamp();
   virtual void setTimestamp(const RTI::FedTime& federateTime);

   virtual const RTI::FedTime& lookahead();
   virtual void setLookahead(const RTI::FedTime& lookaheadValue);

   virtual const RTI::FedTime& galt();
   virtual void setGalt(const RTI::FedTime& federateTime);
#endif


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

#ifdef DtIFSPEC1516
   virtual DtRtiMsg* nextMsg(const rti1516::LogicalTime& timestamp);

   virtual DtRtiMsg* nextTsoMsg(const rti1516::LogicalTime& timestamp);
#elif defined(DtIFSPEC1516E)
   virtual DtRtiMsg* nextMsg(const rti1516e::LogicalTime& timestamp);

   virtual DtRtiMsg* nextTsoMsg(const rti1516e::LogicalTime& timestamp);
#else
   virtual DtRtiMsg* nextMsg(const RTI::FedTime& timestamp);

   virtual DtRtiMsg* nextTsoMsg(const RTI::FedTime& timestamp);
#endif

   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;
#ifdef DtIFSPEC1516
   std::auto_ptr <rti1516::LogicalTime> myTime;
   std::auto_ptr <rti1516::LogicalTimeInterval> myLookahead;
   std::auto_ptr <rti1516::LogicalTime> myGalt;
#elif defined(DtIFSPEC1516E)
   std::auto_ptr <rti1516e::LogicalTime> myTime;
   std::auto_ptr <rti1516e::LogicalTimeInterval> myLookahead;
   std::auto_ptr <rti1516e::LogicalTime> myGalt;
#else
   std::auto_ptr <RTI::FedTime> myTime;
   std::auto_ptr <RTI::FedTime> myLookahead;
   std::auto_ptr <RTI::FedTime> myGalt;
#endif
};

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;
}

#ifdef DtIFSPEC1516
inline const rti1516::LogicalTime& DtRtiMsgQueue::timestamp()
#elif defined(DtIFSPEC1516E)
inline const rti1516e::LogicalTime& DtRtiMsgQueue::timestamp()
#else
inline const RTI::FedTime& DtRtiMsgQueue::timestamp()
#endif
{
   return *myTime;
}

#ifdef DtIFSPEC1516
inline void DtRtiMsgQueue::setTimestamp(
   const rti1516::LogicalTime& federateTime)
#elif defined(DtIFSPEC1516E)
inline void DtRtiMsgQueue::setTimestamp(
    const rti1516e::LogicalTime& federateTime)
#else
inline void DtRtiMsgQueue::setTimestamp(const RTI::FedTime& federateTime)
#endif
{
   *myTime = federateTime;
}

#ifdef DtIFSPEC1516
inline const rti1516::LogicalTimeInterval& DtRtiMsgQueue::lookahead()
#elif defined(DtIFSPEC1516E)
inline const rti1516e::LogicalTimeInterval& DtRtiMsgQueue::lookahead()
#else
inline const RTI::FedTime& DtRtiMsgQueue::lookahead()
#endif
{
   return *myLookahead;
}

#ifdef DtIFSPEC1516
inline void DtRtiMsgQueue::setLookahead(
   const rti1516::LogicalTimeInterval& lookaheadValue)
#elif defined(DtIFSPEC1516E)
inline void DtRtiMsgQueue::setLookahead(
    const rti1516e::LogicalTimeInterval& lookaheadValue)
#else
inline void DtRtiMsgQueue::setLookahead(const RTI::FedTime& lookaheadValue)
#endif
{
   *myLookahead = lookaheadValue;
}

#ifdef DtIFSPEC1516
inline const rti1516::LogicalTime& DtRtiMsgQueue::galt()
#elif defined(DtIFSPEC1516E)
inline const rti1516e::LogicalTime& DtRtiMsgQueue::galt()
#else
inline const RTI::FedTime& DtRtiMsgQueue::galt()
#endif
{
   return *myGalt;
}

#ifdef DtIFSPEC1516
inline void DtRtiMsgQueue::setGalt(const rti1516::LogicalTime& federateTime)
#elif defined(DtIFSPEC1516E)
inline void DtRtiMsgQueue::setGalt(const rti1516e::LogicalTime& federateTime)
#else
inline void DtRtiMsgQueue::setGalt(const RTI::FedTime& federateTime)
#endif
{
   *myGalt = federateTime;
}

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

#endif