ProtocolStack/MessageQueue.cs

using System;
using System.Threading;
using System.Collections;
using Common;

namespace ProtocolStack
{

        public class OutgoingMessageQueue : MessageQueue {
                private DateTime lastTimestampUsed;
                private int lastOffsetUsed;
                private StackInterface thisStack;
                private Thread processingThread;

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

                public void Start() {
                        if (processingThread == null || !processingThread.IsAlive) {
                                lastTimestampUsed = DateTime.MinValue;
                                lastOffsetUsed = 0;
                                processingThread = new Thread(new ThreadStart(DemuxToTransmissionQueues));
                                processingThread.Start();
                        } else {
                                Console.Error.WriteLine("*** \"Messages To Send\" Queue Processing thread already started ***");
                        }
                }

                public void Stop() {
                        if (processingThread != null && processingThread.IsAlive) {
                                processingThread.Abort();
                                processingThread.Join();
                        }
                }
                public void DemuxToTransmissionQueues() {
                        // TODO: Add exception handling stuff.
                        while (true) {
                                Message workingMessage;
                                workingMessage = DequeueBlocking();
                                // TODO: Add low priority message segmentation here
                                try {
                                        if (workingMessage.isLowPriority) {
                                                Console.WriteLine("ProtocolStack: Sending Low Priority");
                                                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);
                                                }
                                        } else {
                                                thisStack.GetRemoteHostByID(workingMessage.Destination).TxQueue.Enqueue(TransmissionQueueEntry.FromMessage(workingMessage), false);
                                        }
                                } catch (ApplicationException appEx) {
                                        Console.Error.WriteLine("*** Unable to send transmission queue object ***\n\n{0}\nSkipping and continuing...", appEx);
                                }
                        }
                }
        }

        public class IncomingMessageQueue : Common.MessageQueue {
                private StackInterface thisStack;

                public void ResetConnection() {
                        // nothing here for the moment
                }

                public IncomingMessageQueue(StackInterface thisStack) {
                        this.thisStack = thisStack;
                }

        }

        

}

---