ProtocolStack/RemoteHostComms.cs

using System;
using System.Collections;


namespace ProtocolStack
{
        public class RemoteHostComms {
                private ReceiveQueue incomingSegementQueue;
                private TransmissionQueue transmissionQueue;
                private SegmentTransmitter segmentTransmitter;
                private NACKManager nackManager;
                private ACKManager ackManager;
                private SequenceManager sequenceManager;
                private RateManager rateManager; 
                private MessageAssembly messageAssembly;
                private RetransmissionBuffer retransmissionBuffer;
                internal StackInterface thisStack;

                internal bool readyToSendUserData;

                public RemoteHostComms(StackInterface thisStack, ushort remoteDeviceID) {
                        this.thisStack = thisStack;
                        RemoteDeviceID = remoteDeviceID;
                        incomingSegementQueue = new ReceiveQueue(this);
                        transmissionQueue = new TransmissionQueue();
                        segmentTransmitter = new SegmentTransmitter(this);
                        nackManager = new NACKManager(this);
                        ackManager = new ACKManager(this);
                        sequenceManager = new SequenceManager(nackManager);
                        rateManager = new RateManager(this);
                        retransmissionBuffer = new RetransmissionBuffer(sequenceManager);
                        messageAssembly = new MessageAssembly(this);
                }
                
                private int remoteDeviceID = -1;

                public void Start() {
                        Console.WriteLine("Starting Remote Host Comms with remote host {0} ...", remoteDeviceID);
                        readyToSendUserData = false;
                        messageAssembly.Start();
                        incomingSegementQueue.Start();
                        segmentTransmitter.Start();
                        ackManager.StartAckableGenerator();
                        Console.WriteLine("... Remote Host Comms with remote host {0} Started", remoteDeviceID);
                }

                public void Stop() {
                        Console.WriteLine("Stopping Remote Host Comms with remote host {0} ...", remoteDeviceID);
                        ackManager.StopAckableGenerator();
                        segmentTransmitter.Stop();
                        incomingSegementQueue.Stop();
                        messageAssembly.Stop();
                        Console.WriteLine("... Remote Host Comms with remote host {0} Stopped", remoteDeviceID);
                }

                public void ResetConnection() {
                        Console.WriteLine("Reseting Remote Host Comms with remote host {0} ...", remoteDeviceID);
                        readyToSendUserData = false;
                        transmissionQueue.ResetConnection();
                        nackManager.ResetConnections();
                        ackManager.ResetConnection();
                        sequenceManager.ResetConnection();
                        rateManager.ResetConnection();
                        retransmissionBuffer.ResetConnection();
                        Console.WriteLine("... Remote Host Comms with remote host {0} Reset", remoteDeviceID);
                }

                public ushort RemoteDeviceID {
                        get { if (remoteDeviceID != -1) {
                                          return (ushort)remoteDeviceID;
                                  } else {
                                          throw new ApplicationException("Unable to return remote device ID - no remote device ID set");
                                  }
                        }
                        set { remoteDeviceID = value; }
                }

                public void AcceptIncomingSegment(Segment incomingSegment) {
                        incomingSegementQueue.EnqueueBlocking(incomingSegment); // Can we do better than this?
                }
        

                public NACKManager NackManager {
                        get { return nackManager; }
                        set { nackManager = value; }
                }

                public ACKManager AckManager {
                        get { return ackManager; }
                        set { ackManager = value; }
                }

                public SequenceManager SeqManager {
                        get { return sequenceManager; }
                        set { sequenceManager = value; }
                }

                public RateManager RateManager {
                        get { return rateManager; }
                        set { rateManager = value; }
                }


                public RetransmissionBuffer RetransmissionBuffer {
                        get {return retransmissionBuffer; }
                        set {retransmissionBuffer = value; }
                }

                public TransmissionQueue TxQueue {
                        get { return transmissionQueue; }
                        set { transmissionQueue = value; }
                }

                public MessageAssembly MessageAssembler {
                        get { return messageAssembly; }
                        set { messageAssembly = value; }
                }




        }
}

---