src/jabber_whiteboard/message-queue.h

   1 /**
   2  * Whiteboard message queue
   3  *
   4  * Authors:
   5  * David Yip <yipdw@rose-hulman.edu>
   6  *
   7  * Copyright (c) 2005 Authors
   8  *
   9  * Released under GNU GPL, read the file 'COPYING' for more information
  10  */
  11
  12 #ifndef __WHITEBOARD_MESSAGE_QUEUE_H__
  13 #define __WHITEBOARD_MESSAGE_QUEUE_H__
  14
  15 #include <list>
  16 #include <map>
  17
  18 #include "gc-alloc.h"
  19 #include "gc-managed.h"
  20
  21 #include "util/list-container.h"
  22
  23 namespace Inkscape {
  24
  25 namespace Whiteboard {
  26
  27 class MessageNode;
  28
  29 /// Definition of the basic message node queue
  30 typedef std::list< MessageNode*, GC::Alloc< MessageNode*, GC::MANUAL > > MessageQueueBuffer;
  31
  32 /**
  33  * MessageQueue interface.
  34  *
  35  * A message queue is used to queue up document change messages for sending and receiving.
  36  *
  37  * Message queues exist to allow us to send/process messages at a given rate rather than
  38  * immediately: this allows us to avoid flooding Jabber servers and clients.
  39  *
  40  * Only one message queue should be created per sender.  Message queues store MessageNodes.
  41  *
  42  * \see Inkscape::Whiteboard::MessageNode
  43  */
  44 class MessageQueue {
  45 public:
  46         /**
  47          * Constructor.
  48          *
  49          * \param sm The SessionManager to associate this MessageQueue with.
  50          */
  51         MessageQueue() { }
  52         virtual ~MessageQueue()
  53         {
  54                 this->_queue.clear();
  55         }
  56
  57         /**
  58          * Retrieve the MessageNode at the front of the queue.
  59          */
  60         virtual MessageNode* first();
  61
  62         /**
  63          * Remove the element at the front of the queue.
  64          */
  65         virtual void popFront();
  66
  67         /**
  68          * Get the size of the queue.
  69          *
  70          * \return The size of the queue.
  71          */
  72         virtual unsigned int size();
  73
  74         /**
  75          * Returns whether or not the queue is empty.
  76          *
  77          * \return Whether or not the queue is empty.
  78          */
  79         virtual bool empty();
  80
  81         /**
  82          * Clear the queue.
  83          */
  84         virtual void clear();
  85
  86         /**
  87          * The insertion method.  The insertion procedure must be defined
  88          * by a subclass.
  89          *
  90          * \param msg The MessageNode to insert.
  91          */
  92         virtual void insert(MessageNode* msg) = 0;
  93
  94 protected:
  95         /**
  96          * Implementation of the queue.
  97          */
  98         MessageQueueBuffer _queue;
  99 };
 100
 101
 102 /**
 103  * MessageQueue subclass designed to queue up received messages.
 104  * Received messages are dispatched for processing on a periodic basis by a timeout.
 105  *
 106  * \see Inkscape::Whiteboard::Callbacks::dispatchReceiveQueue
 107  */
 108 class ReceiveMessageQueue : public MessageQueue, public GC::Managed<> {
 109 public:
 110         ReceiveMessageQueue() : _latest(0) { }
 111
 112         /**
 113          * Insert a message into the queue.
 114          * Late messages (out-of-sequence messages) will be discarded.
 115          *
 116          * \param msg The message node to insert.
 117          */
 118         void insert(MessageNode* msg);
 119
 120         /**
 121          * Insert a message into the deferred queue.
 122          * The deferred message queue is used for messages that are not discarded,
 123          * but cannot yet be processed due to missing dependencies.
 124          *
 125          * \param msg The message node to insert.
 126          */
 127         void insertDeferred(MessageNode* msg);
 128
 129         /**
 130          * Update the latest processed packet count for this message queue.
 131          *
 132          * \param seq The sequence number of the latest processed packet.
 133          */
 134         void setLatestProcessedPacket(unsigned int seq);
 135 private:
 136         MessageQueueBuffer _deferred;
 137         unsigned int _latest;
 138 };
 139
 140 /**
 141  * MessageQueue subclass designed to queue up messages for sending.
 142  * Messages in this queue are dispatched on a periodic basis by a timeout.
 143  *
 144  * \see Inkscape::Whiteboard::Callbacks::dispatchSendQueue
 145  */
 146 class SendMessageQueue : public MessageQueue {
 147 public:
 148         SendMessageQueue() { }
 149
 150         /**
 151          * Insert a message into the queue.
 152          *
 153          * \param msg The message node to insert.
 154          */
 155         void insert(MessageNode* msg);
 156 };
 157
 158 }
 159
 160 }
 161
 162 #endif
 163
 164 /*
 165   Local Variables:
 166   mode:c++
 167   c-file-style:"stroustrup"
 168   c-file-offsets:((innamespace . 0)(inline-open . 0))
 169   indent-tabs-mode:nil
 170   fill-column:99
 171   End:
 172 */
 173 // vim: filetype=c++:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :