private TimeSpan GetFrequencyTimeSpan(MessageFrequency frequency)
{
switch (frequency)
{
case MessageFrequency.Minute:
return(new TimeSpan(0, 1, 0));
case MessageFrequency.Hour:
return(new TimeSpan(1, 0, 0));
case MessageFrequency.Day:
return(new TimeSpan(1, 0, 0, 0));
default:
return(new TimeSpan());
}
}
/* Blank message snippet to copy from for new messages:
*
* public X()
* {
* Id = MessageId.X;
* Flags = 0;
* Frequency = MessageFrequency.X;
* }
*
#region DeSerialise
* protected override void DeSerialise(byte[] buf, ref int o, int length)
* {
* }
#endregion DeSerialise
*
* public override string ToString()
* {
* return $"{base.ToString()}: Y={Y}, Z={Z}";
* }
*/
/// <summary>
/// Creates a message based on the data in the given buffer.
/// </summary>
/// <param name="buf"></param>
/// <param name="o"></param>
/// <returns></returns>
public static Message DeSerializeMessage(byte[] buf, ref int o)
{
if (buf.Length - o < 6)
{
throw new Exception("Message.CreateMessage: Not enough room in buffer.");
}
#region Header
PacketFlags packetFlags = (PacketFlags)buf[o++];
UInt32 sequenceNumber = (((UInt32)buf[o++]) << 24)
+ (((UInt32)buf[o++]) << 16)
+ (((UInt32)buf[o++]) << 8)
+ (((UInt32)buf[o++]) << 0);
byte extraHeaderLength = buf[o++];
byte[] extraHeader = new byte[extraHeaderLength];
for (int i = 0; i < extraHeaderLength; i++)
{
extraHeader[i] = buf[o++];
}
#endregion Header
#region AppendedAcks
List <UInt32> acks = new List <UInt32>();
int ackLength = 0;
if ((packetFlags & PacketFlags.Ack) != 0)
{
byte nAcks = buf[buf.Length - 1];
ackLength = nAcks * 4 + 1;
int ackOffset = buf.Length - ackLength;
for (int i = 0; i < nAcks; i++)
{
UInt32 ack = BinarySerializer.DeSerializeUInt32_Be(buf, ref ackOffset, buf.Length);
acks.Add(ack);
}
}
#endregion AppendedAcks
#region MessageId
MessageFrequency frequency = MessageFrequency.High;
UInt32 id = buf[o++];
if (id == 0xff)
{
id = (id << 8) + buf[o++];
frequency = MessageFrequency.Medium;
if (id == 0xffff)
{
id = id << 16;
id += ((UInt32)buf[o++]) << 8;
id += ((UInt32)buf[o++]) << 0;
frequency = id < 0xfffffffa ? MessageFrequency.Low : MessageFrequency.Fixed;
}
}
if (id == (UInt32)MessageId.Wrapper)
{
id = 0xffff0000 + buf[o++];
}
if (Enum.IsDefined(typeof(MessageId), id) == false || MessageCreator.ContainsKey((MessageId)id) == false)
{
string idString = "";
switch (frequency)
{
case MessageFrequency.High:
case MessageFrequency.Medium:
idString = $"{frequency} {id & 0xff} (0x{id:x8})";
break;
case MessageFrequency.Low:
idString = $"{frequency} {id & 0xffff} (0x{id:x8})";
break;
case MessageFrequency.Fixed:
idString = $"{frequency} 0x{id:x8}";
break;
}
// Only log unknown messages the first time to reduce spam and lag:
if (UnknownMessageIds.Contains(id) == false)
{
Logger.LogError($"BinarySerializer.DeSerializeMessage: Unknown message id {idString}");
UnknownMessageIds.Add(id);
}
return(new Message
{
Flags = packetFlags,
SequenceNumber = sequenceNumber,
Acks = acks,
ExtraHeader = extraHeader
});
}
MessageId messageId = (MessageId)id;
#endregion MessageId
#region DataBuffer
byte[] dataBuffer = buf;
int dataOffset = o;
int dataLen = buf.Length - ackLength;
if ((packetFlags & PacketFlags.ZeroCode) != 0)
{
dataBuffer = BinarySerializer.ExpandZerocode(buf, o, dataLen - o);
dataOffset = 0;
dataLen = dataBuffer.Length;
}
#endregion DataBuffer
Message message = MessageCreator[messageId]();
message.Flags = packetFlags;
message.SequenceNumber = sequenceNumber;
message.ExtraHeader = extraHeader;
message.Acks = acks;
message.DeSerialise(dataBuffer, ref dataOffset, dataLen);
//Logger.LogDebug ($"Message.DeSerialiseMessage: {message}");
return(message);
}
