util/queue/MsgQueueEntry.h

Go to the documentation of this file.

/*------------------------------------------------------------------------------
Name:      MsgQueueEntry.h
Project:   xmlBlaster.org
Copyright: xmlBlaster.org, see xmlBlaster-LICENSE file
------------------------------------------------------------------------------*/

#ifndef _UTIL_QUEUE_MSGQUEUEENRY_H
#define _UTIL_QUEUE_MSGQUEUEENRY_H

#include <util/xmlBlasterDef.h>
#include <util/Timestamp.h>
#include <util/MessageUnit.h>
#include <util/qos/ConnectQos.h>
#include <client/qos/PublishQos.h>
#include <client/qos/PublishReturnQos.h>
#include <util/ReferenceCounterBase.h>
#include <util/qos/StatusQosData.h>
#include <util/qos/QueryQosData.h>
#include <util/key/QueryKeyData.h>
//#include <util/msgUtil.h> // from xmlBlaster C library
//#include <socket/xmlBlasterSocket.h> // from xmlBlaster C library ::encodeMsgUnit(&msgUnit, debug);

// circular dependency I_ConnectionsHandler -> Queue -> MsgQueueEntry
#ifndef _UTIL_DISPATCH_ICONNECTIONSHANDLER_H
namespace org { namespace xmlBlaster { namespace util { namespace dispatch {
class I_ConnectionsHandler;
}}}}
#endif



namespace org { namespace xmlBlaster { namespace util { namespace queue {

typedef struct {
   size_t dataLen; // size_t is the unsigned integer size result of a sizeof operator. Change to uint32_t ?
   char *data;
} BlobHolder;

class Dll_Export MsgQueueEntry : public ReferenceCounterBase
{
protected:
   std::string ME;
   mutable org::xmlBlaster::util::Global& global_;
   org::xmlBlaster::util::I_Log& log_;
   int priority_;
   bool persistent_;
   org::xmlBlaster::util::Timestamp uniqueId_;
   std::string embeddedType_;
   std::string logId_;
   org::xmlBlaster::util::MessageUnit* msgUnit_;
   /* TODO: Change that connectQos, queryQos all derive from QosData and are transported inside msgUnit */
   org::xmlBlaster::util::qos::ConnectQosRef connectQos_;

   mutable org::xmlBlaster::util::qos::ConnectReturnQosRef connectReturnQos_;
   mutable const org::xmlBlaster::client::qos::PublishReturnQos* publishReturnQos_;
   mutable org::xmlBlaster::util::qos::StatusQosData* statusQosData_;

   mutable BlobHolder blobHolder_;
   
public:

    MsgQueueEntry(org::xmlBlaster::util::Global& global,
                  const org::xmlBlaster::util::MessageUnit& msgUnit,
                  const std::string& embeddedType,
                  int priority,
                  bool persistent,
                  org::xmlBlaster::util::Timestamp uniqueId = TimestampFactory::getInstance().getTimestamp());

    MsgQueueEntry(org::xmlBlaster::util::Global& global,
                  const org::xmlBlaster::util::qos::ConnectQosRef& connectQos,
                  const std::string& embeddedType,
                  int priority,
                  bool persistent,
                  org::xmlBlaster::util::Timestamp uniqueId = TimestampFactory::getInstance().getTimestamp());


    MsgQueueEntry(org::xmlBlaster::util::Global& global,
                  const org::xmlBlaster::util::key::QueryKeyData& queryKeyData,
                  const org::xmlBlaster::util::qos::QueryQosData& queryQosData,
                  const std::string& embeddedType,
                  int priority,
                  bool persistent,
                  org::xmlBlaster::util::Timestamp uniqueId = TimestampFactory::getInstance().getTimestamp());


    virtual ~MsgQueueEntry();

    org::xmlBlaster::util::Global& getGlobal() const { return global_; }

    void copy(const MsgQueueEntry& entry);

    MsgQueueEntry(const MsgQueueEntry& entry);

    MsgQueueEntry& operator =(const MsgQueueEntry& entry);

    inline bool operator == (const MsgQueueEntry& entry)
    {
       if (priority_ != entry.priority_) return false;
       return (uniqueId_ == entry.uniqueId_);
    }

    inline bool operator < (const MsgQueueEntry& entry)
    {
       if (priority_ < entry.priority_) return true;
       if (priority_ > entry.priority_) return false;
       return (uniqueId_ > entry.uniqueId_);
    }

    virtual MsgQueueEntry *getClone() const = 0;

   int getPriority() const;

   bool isPersistent() const;

   void setSender(org::xmlBlaster::util::SessionNameRef sender);

   org::xmlBlaster::util::Timestamp getUniqueId() const;

   virtual const void* getEmbeddedObject() const;

   virtual std::string getEmbeddedType() const;
   
   virtual bool isConnect() const;

   virtual bool isPublish() const;

   virtual bool isSubscribe() const;

   virtual bool isUnSubscribe() const;

   virtual bool isErase() const;


   std::string getLogId() const;

   virtual size_t getSizeInBytes() const;

   org::xmlBlaster::util::MessageUnit& getMsgUnit() const;

   //org::xmlBlaster::util::qos::QueryQosData& getQueryQosData() const;
   //org::xmlBlaster::util::key::QueryKeyData& getQueryKeyData() const;



   // this should actually be in another interface but since it is an only method we put it here.
   virtual const MsgQueueEntry& send(org::xmlBlaster::util::dispatch::I_ConnectionsHandler&) const; // = 0;
   
   virtual std::string toXml(const std::string& indent="") const; // = 0;

};

}}}} // namespace

#endif