SmartDeviceClient/SmartProtocolStack/ProtocolMessages.cs

using System;
using System.IO;
using GPRSWeb.SmartDeviceClient.Common;

namespace GPRSWeb.SmartDeviceClient.SmartProtocolStack {
        /************************************************************************/
        public class EmptyMessage : Message {
                public override MemoryStream SerialiseData() {
                        return new MemoryStream(0);
                }

                public override void DeserialiseData(Stream serialisedDataStream) {
                        if (serialisedDataStream.Length != 0) {
                                throw new ApplicationException("Attempting to deserialise empty message, and messgae isn't empty!");
                        } else {
                                /* do nothing */
                        }
                }

                public EmptyMessage() : base(MessageType.Noop) {}
                public EmptyMessage(ushort destinationDeviceID) : base(MessageType.Noop, destinationDeviceID) {}
        }

        /************************************************************************/
        public class RetransmissionMessage : Message {
                private Segment data;

                public Segment RawSegment {
                        get { return data; }
                }

                public override MemoryStream SerialiseData() {
                        return data.Serialise();
                }

                public override void DeserialiseData(Stream serialisedDataStream) {
                        data = new Segment(serialisedDataStream);
                }

                public RetransmissionMessage(ushort destination) : base(MessageType.Retransmission, destination) {}
                public RetransmissionMessage(ushort destination, Segment src) : this(destination) {
                        data = src;
                }
        }
        /************************************************************************/
        public class MessageChunk : Message {
                private static readonly int MAX_DATA_SIZE = SegmentData.MAX_DATA_SIZE - 4 - 4 - 4 - 8 -2 -1;
                // 2 * 4 byte for 1st/last, 4 bytes for int, 8 bytes for dateTime.Ticks (long)
                // -2 is to allow for 2 byte difference between segment data and (length,segment data) 
                // returned by SegmentData.toByteArray();
                // the -1 is to account for the Type byte that Message.ToByteArray prepends to the data
                public int firstInMessage;
                public int lastInMessage;
                public int offset;
                public DateTime timestamp;
                public SegmentData segmentData;

                public static MessageChunk[] GetChunksFromMessage(Message msg, ref DateTime lastTimestampUsed, ref int lastOffsetUsed) {
                        SegmentData[] segmentDataArr = SegmentData.FromMessage(msg, MAX_DATA_SIZE);
                        MessageChunk[] resultArr = new MessageChunk[segmentDataArr.Length];
                        DateTime now = DateTime.Now;
                        int currentOffset;
                        if (now == lastTimestampUsed) {
                                currentOffset = lastOffsetUsed + 1;
                        } else {
                                currentOffset = 0;
                        }
                        int initialOffset = currentOffset;
                        // do work
                        for(int i = 0; i < segmentDataArr.Length; i++) {
                                resultArr[i] = new MessageChunk(segmentDataArr[i], now, currentOffset);
                                resultArr[i].firstInMessage = initialOffset;
                                resultArr[i].lastInMessage = initialOffset + segmentDataArr.Length - 1; // zero-correction
                                currentOffset++;
                        }
                        // set last used variables correctly
                        lastOffsetUsed = currentOffset;
                        lastTimestampUsed = now;
                        return resultArr;
                }

                public static SegmentData[] GetMessageFromChunks(MessageChunk[] chunks) {
                        SegmentData[] dataChunks = new SegmentData[chunks.Length];
                        for(int i = 0; i < chunks.Length; i++) {
                                dataChunks[i] = chunks[i].segmentData;
                        }
                        return dataChunks;
                }


                public MessageChunk(SegmentData data, DateTime timestamp, int offset) : base(MessageType.Chunk) {
                        this.segmentData = data;
                        this.timestamp = timestamp;
                        this.offset = offset;
                }

                public MessageChunk(byte[] src) : base(MessageType.Chunk) {
                        Deserialise(src);
                }

                public override MemoryStream SerialiseData() {
                        return new MemoryStream(Serialise2());
                }


                private byte[] Serialise2() {
                        byte[] firstInMessageByte = BitConverter.GetBytes(this.firstInMessage);
                        byte[] lastInMessageByte = BitConverter.GetBytes(this.lastInMessage);
                        byte[] offsetBytes = BitConverter.GetBytes(this.offset);
                        byte[] timestampBytes = BitConverter.GetBytes(this.timestamp.Ticks);
                        byte[] result = new byte[firstInMessageByte.Length + lastInMessageByte.Length + offsetBytes.Length + timestampBytes.Length + segmentData.ToByteArray().Length];
                        MemoryStream ms = new MemoryStream(result);
                        ms.Write(firstInMessageByte, 0, firstInMessageByte.Length);
                        ms.Write(lastInMessageByte, 0, lastInMessageByte.Length);
                        ms.Write(offsetBytes, 0, offsetBytes.Length);
                        ms.Write(timestampBytes, 0, timestampBytes.Length);
                        ms.Write(segmentData.ToByteArray(), 0, segmentData.ToByteArray().Length);
                        ms.Close();
                        return result;
                }

                public override void DeserialiseData(Stream serialisedDataStream) {
                        byte[] buffer = new byte[serialisedDataStream.Length];
                        Deserialise2(buffer);
                }

                private void Deserialise2(byte[] src) {
                        int currentPos = 0;
                        firstInMessage = BitConverter.ToInt32(src, currentPos);
                        currentPos+=4;
                        lastInMessage = BitConverter.ToInt32(src, currentPos);
                        currentPos+=4;
                        offset = BitConverter.ToInt32(src, currentPos);
                        currentPos += 4;
                        timestamp = new DateTime(BitConverter.ToInt64(src, currentPos));
                        currentPos += 8;
//                      byte[] segDataBytes = new byte[src.Length - currentPos];
//                      Array.Copy(src, currentPos, segDataBytes, 0, segDataBytes.Length);
                        segmentData = new SegmentData();
                        segmentData.FromByteArray(ref src, ref currentPos);
                }

        }
}

---