OutgoingMessageQueue.cs

using System;
using System.Threading;
using GPRSWeb.SmartDeviceClient.Common;

namespace GPRSWeb.SmartDeviceClient.SmartProtocolStack
{
        public class OutgoingMessageQueue : MessageQueue {
                private DateTime lastTimestampUsed; // used in chunkifying low priority messages
                private int lastOffsetUsed; // used in chunkifying low priority messages
                private StackInterface thisStack; // controlling stack interfacce
                private Thread processingThread; // processing thread

                public OutgoingMessageQueue(StackInterface thisStack) : base() {
                        this.thisStack = thisStack;
                }

                protected void Initialise() {
                        lastTimestampUsed = DateTime.MinValue;
                        lastOffsetUsed = 0;
                }

                public void Start() {
                        processingThread = new Thread(new ThreadStart(ProcessQueue));
                        processingThread.Start();
                }

                protected void ProcessQueue() {
                        Message workingMessage; // the message we're currently working on
                        while (true) {
                                workingMessage = this.DequeueBlocking(); // get 
                                try {
                                        switch (workingMessage.Priority) {
                                                case MessagePriority.Low : {
                                                        ProcessLowPriorityMessage(workingMessage); 
                                                        break;
                                                }
                                                case MessagePriority.Normal : {
                                                        ProcessNormalPriorityMessage(workingMessage);
                                                        break;
                                                }
                                                case MessagePriority.High : {
                                                        processHighPriorityMessage(workingMessage);
                                                        break;
                                                }
                                                default: { 
                                                        thisStack.msgLog.LogError("Outgoing Message Queue was unable to determine prioriry of outgoing message");
                                                        break;
                                                }
                                        }
                                } catch (ApplicationException appEx) {
                                        thisStack.msgLog.LogError("Outgoing Message Queue was unable to redirect a message for transmission. Continuing...\r\n{0}", appEx);
                                }
                        }
                }

                protected void ProcessLowPriorityMessage(Message messageToProcess) {
                        MessageChunk[] chunks = MessageChunk.GetChunksFromMessage(workingMessage, ref lastTimestampUsed, ref lastOffsetUsed);
                        foreach (MessageChunk chunk in chunks) {
                                chunk.Destination = workingMessage.Destination;
                                chunk.Source = 0;
                                thisStack.GetRemoteHostByID(chunk.Destination).TxQueue.Enqueue(TransmissionQueueEntry.FromMessage(chunk, true), true);
                        }
                }

                protected void ProcessNormalPriorityMessage(Message messageToProcess) {
                        thisStack.GetRemoteHostByID(messageToProcess.Destination).TxQueue.Enqueue(TransmissionQueueEntry.FromMessage(workingMessage), false);
                }

                protected void ProcessHighPriorityMessage(Message messageToProcess) {
                        throw new ApplicationException("Sending High Priority Messages is not implemented");
                }
        } // end class
} // end namespace

---