static async Task ReadPipeAsync(PipeReader reader, CsvWriter csvWriter, Mapper mapper)
{
while (true)
{
var result = await reader.ReadAsync();
ReadOnlySequence <byte> buffer = result.Buffer;
while (TryReadCarUpdateDatagram(ref buffer, out var completeDatagram))
{
var carData = StructSerializer
.Deserialize <CarUpdateDatagram>(completeDatagram.ToArray(), 0);
var carModel = mapper.Map <CarStateModel>(carData);
csvWriter.NextRecord();
csvWriter.WriteRecord(carModel);
}
reader.AdvanceTo(buffer.Start, buffer.End);
if (result.IsCompleted)
{
break;
}
}
await reader.CompleteAsync();
}
protected override void Write(IFileWriter dataWriter, DataChunk chunk)
{
var prefixSize = StructSerializer.GetSize <GzipChunkPrefix>();
using (MemoryStream memoryStream = new MemoryStream(prefixSize + chunk.Data.Length))
{
using (GZipStream compressionStream = new GZipStream(memoryStream, CompressionMode.Compress, leaveOpen: true))
{
memoryStream.Position = prefixSize;
compressionStream.Write(chunk.Data, 0, chunk.Data.Length);
}
var prefix = new GzipChunkPrefix()
{
ChunkSize = chunk.Data.Length,
Offset = chunk.Offset,
GzipDataSize = (int)memoryStream.Length - prefixSize
};
memoryStream.Position = 0;
var prefixBytes = StructSerializer.Serialize(prefix);
memoryStream.Write(prefixBytes, 0, prefixBytes.Length);
memoryStream.Capacity = (int)memoryStream.Length;
var compressedData = memoryStream.GetBuffer();
var offset = Interlocked.Add(ref _writeOffset, compressedData.Length) - compressedData.Length;
dataWriter.WriteChunk(offset, compressedData);
}
}
public void TestOnlyAByte()
{
var obj = new OnlyAByte(0xab);
var onlyAByteSerializer = new StructSerializer(new BaseSerializer[] { new ByteSerializer(obj.F1) });
var expected = new byte[] { 0xab };
Assert.Equal(expected, onlyAByteSerializer.Serialize());
}
/// <summary>
/// Converts the struct to a memory stream in host-endian format (little-endian on PCs).
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="source">The structure.</param>
/// <returns></returns>
public static MemoryStream ToStream <T>([NotNull] this T source)
where T : struct
{
source.ThrowIfNull(nameof(source));
var ms = new MemoryStream();
StructSerializer.Serialize(ms, source);
return(ms);
}
public void TestByteAndUInt32()
{
var obj = new ByteAndUInt32()
{
F1 = 0xab,
F2 = 0x010203,
};
var byteAndUInt32Serializer = new StructSerializer(new BaseSerializer[] { new ByteSerializer(obj.F1), new UInt32Serializer(obj.F2) });
byte[] expected = new byte[] { 0xab, 0x03, 0x02, 0x01, 0x00 };
Assert.Equal(expected, byteAndUInt32Serializer.Serialize());
}
public static IAxSerializer WriteStruct <T>(this IAxSerializer s, ref T source) where T : struct
{
Delegate @delegate;
bool flag = !Delegates.TryGetValue(typeof(T), out @delegate);
if (flag)
{
@delegate = Serializer.GetDynamicSerializer(typeof(T)).CreateDelegate(typeof(StructSerializer <T>));
}
StructSerializer <T> structSerializer = (StructSerializer <T>)@delegate;
structSerializer(s, ref source);
return(s);
}
public void TestReadStructArray()
{
var item1 =
new CachedFileHeaderStruct
{
lenPath = 1
};
var serializer = new StructSerializer <CachedFileHeaderStruct>();
byte[] bytes = serializer.ToByteArray(item1);
Assert.AreEqual(Marshal.SizeOf <CachedFileHeaderStruct>(), bytes.Length);
var roundTrip = serializer.FromByteArray(bytes);
Assert.AreEqual(item1, roundTrip);
}
private void _bluetooth_DataReceived(object sender, EventArgs e)
{
//DeviceStream stream = new DeviceStream(_bluetooth);
//Message message = await Transport.Read<Message>(stream);
byte[] buffer = _bluetooth.ReadAll();
MessageHeader header = StructSerializer.DeserializeStruct <MessageHeader>(buffer);
if (header.Type == MessageType.Command)
{
CommandMessage command = StructSerializer.DeserializeStruct <CommandMessage>(buffer);
Console.WriteLine("command {0} = {1},{2}", command.Device.Hash, command.Device.IValue, command.Device.DValue);
//IComponent component = _components.SingleOrDefault(i => i.Name)
}
}
static YamlObjectSerializer()
{
_structSerializer = new StructSerializer();
_typeSerializers = new Dictionary <Type, TypeSerializer>
{
{ typeof(Color), new ColorSerializer() },
{ typeof(Vector2), new Vector2Serializer() },
{ typeof(Angle), new AngleSerializer() },
{ typeof(Box2), new Box2Serializer() },
{ typeof(ResourcePath), new ResourcePathSerializer() },
{ typeof(GridId), new GridIdSerializer() },
{ typeof(MapId), new MapIdSerializer() },
{ typeof(SpriteSpecifier), new SpriteSpecifierSerializer() },
};
}
public static CacheHeaderStruct Read(Stream stream)
{
StructSerializer <CacheHeaderStruct> minimumStructSerializer = GetStructSerializer(CacheFormatVersion.Two);
stream.Seek(-minimumStructSerializer.ItemSizeOnDisk, SeekOrigin.End);
CacheHeaderStruct minimumStruct = minimumStructSerializer.ReadArray(stream, 1)[0];
StructSerializer <CacheHeaderStruct> actualStructSerializer =
GetStructSerializer(minimumStruct.formatVersion);
if (actualStructSerializer.ItemSizeOnDisk == minimumStructSerializer.ItemSizeOnDisk)
{
return(minimumStruct);
}
stream.Seek(-actualStructSerializer.ItemSizeOnDisk, SeekOrigin.End);
return(actualStructSerializer.ReadArray(stream, 1)[0]);
}
public void TestShorterSizeOnDisk()
{
var item1 = new CachedFileHeaderStruct
{
modified = 1,
lenInstrumentInfo = 100,
};
var serializer = new StructSerializer <CachedFileHeaderStruct>()
{
ItemSizeOnDisk = 8
};
byte[] bytes = serializer.ResizeByteArray(serializer.ToByteArray(item1), 8);
Assert.AreEqual(8, bytes.Length);
var roundTrip = serializer.FromByteArray(bytes);
Assert.AreEqual(1, roundTrip.modified);
Assert.AreEqual(0, roundTrip.lenInstrumentInfo);
}
protected override DataChunk Read(IFileReader dataReader)
{
long offset;
GzipChunkPrefix prefix;
DataChunk dataChunk = null;
lock (_locker)
{
if (_readOffset >= dataReader.Size)
{
return(null);
}
var prefixSize = StructSerializer.GetSize <GzipChunkPrefix>();
var prefixBytes = dataReader.ReadChunk(_readOffset, prefixSize);
prefix = StructSerializer.Deserialize <GzipChunkPrefix>(prefixBytes);
offset = _readOffset + prefixSize;
_readOffset = offset + prefix.GzipDataSize;
}
var decompressedData = new byte[prefix.ChunkSize];
var data = dataReader.ReadChunk(offset, prefix.GzipDataSize);
using (MemoryStream memoryStream = new MemoryStream(data))
{
using (GZipStream decompressionStream = new GZipStream(memoryStream, CompressionMode.Decompress, leaveOpen: true))
{
var decompressedDataSize = decompressionStream.Read(decompressedData, 0, prefix.ChunkSize);
if (decompressedDataSize != prefix.ChunkSize)
{
Console.WriteLine("The specified compressed file is malformed.");
}
}
dataChunk = new DataChunk(prefix.Offset, decompressedData);
}
return(dataChunk);
}
public void Dispatch(DeviceLookup lookup)
{
//Update values
DateTime now = DateTime.Now;
for (int i = 0; i < _config.Count; i++)
{
int messageIndex = i / TelemetryMessage.EntryLength;
int entryIndex = i % TelemetryMessage.EntryLength;
DeviceValue entry = _messages[messageIndex].Devices[entryIndex];
object value = lookup[entry.Hash].Get();
if (lookup[entry.Hash].Property.PropertyType == typeof(Int32))
{
_messages[messageIndex].Devices[entryIndex].IValue = (Int32)value;
}
else if (lookup[entry.Hash].Property.PropertyType == typeof(float))
{
_messages[messageIndex].Devices[entryIndex].DValue = (float)value;
}
else
{
Console.WriteLine("Unknown Type: {0}", lookup[entry.Hash].Property.PropertyType);
}
}
//Send packets
foreach (TelemetryMessage message in _messages)
{
//var m = message;
//m.Header.DateTime = now;
//Send telemetry
byte[] buffer = StructSerializer.Serialize(message);
_stream.Write(buffer);
}
}
/// <summary> /// Convert the bytes to a structure in host-endian format (little-endian on PCs). /// To use with big-endian data, reverse all of the data bytes and create a struct that is in the reverse order of the data. /// </summary> /// <typeparam name="T">The structure's type</typeparam> /// <param name="source">The buffer.</param> /// <returns></returns> public static T ToStruct <T>([NotNull] this byte[] source) where T : struct => StructSerializer.Deserialize <T>(source.GetOrThrowIfNull(nameof(source)));
static async Task Main(string[] args)
{
// udp server configuration
var serverIpAddress = IPAddress.Parse("192.168.1.53");
var serverPort = 9996;
var serverEndpoint = new IPEndPoint(serverIpAddress, serverPort);
// automapper initialization for mapping interop Datagrams => Models
// NTS: Install-Package AutoMapper.Extensions.Microsoft.DependencyInjection
MapperConfiguration config = new MapperConfiguration(
cfg =>
{
cfg.CreateMap <HandshakeResponseDatagram, HandshakeResponseModel>();
cfg.CreateMap <CarUpdateDatagram, CarStateModel>();
}
);
var mapper = new Mapper(config);
var handshakeRequest = new TelemetryServerConfigurationDatagram()
{
identifier = PlatformType.Web,
version = 1,
operationId = OperationType.Handshake
};
// serialize request
var requestByteArray = StructSerializer.Serialize(handshakeRequest);
// send request and block for response
using var client = new UdpClient();
client.Connect(serverEndpoint);
client.Send(requestByteArray, Marshal.SizeOf(typeof(TelemetryServerConfigurationDatagram)));
var responseByteArray = client.Receive(ref serverEndpoint);
// deserialize and map to model
var handshakeResponse = StructSerializer.Deserialize <HandshakeResponseDatagram>(responseByteArray, 0);
var handshakeOutput = mapper.Map <HandshakeResponseModel>(handshakeResponse);
// print result of handshake
Console.WriteLine(handshakeOutput);
var updateRequest = new TelemetryServerConfigurationDatagram()
{
identifier = PlatformType.Web,
operationId = OperationType.SubscriberUpdate,
version = 1
};
requestByteArray = StructSerializer.Serialize(updateRequest);
await client.SendAsync(requestByteArray, Marshal.SizeOf(typeof(TelemetryServerConfigurationDatagram)));
var path = $"telemetry/" +
$"{handshakeOutput.DriverName}/" +
$"{handshakeOutput.TrackName}/" +
$"{handshakeOutput.CarName}/";
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
using var streamWriter = new StreamWriter($"{path}/{DateTime.Now.ToFileTime()}.csv");
using var csvWriter = new CsvWriter(streamWriter, CultureInfo.InvariantCulture);
csvWriter.WriteHeader(typeof(CarStateModel));
Console.CancelKeyPress += (sender, e) =>
{
csvWriter.Flush();
streamWriter.Close();
csvWriter.Dispose();
streamWriter.Dispose();
var disconnect = new TelemetryServerConfigurationDatagram()
{
identifier = PlatformType.Web,
operationId = OperationType.Dismiss,
version = 1
};
requestByteArray = StructSerializer.Serialize(disconnect);
client.Send(requestByteArray, Marshal.SizeOf(typeof(TelemetryServerConfigurationDatagram)));
Console.WriteLine("Exiting Gracefully...");
Environment.Exit(0);
};
await ProcessSubscriberUpdates(client, csvWriter, mapper);
}
public Eeprom()
{
this.lockSlim = new ReaderWriterLockSlim();
this.byteEeprom = StructSerializer.StructureToByteArray(this.eeprom);
}
/// <summary>
/// Converts the struct to a byte array in host-endian format (little-endian on PCs).
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="source">The structure.</param>
/// <returns></returns>
public static byte[] ToBytes <T>([NotNull] this T source)
where T : struct => StructSerializer.Serialize(source);
static void TestASyncMessage(int count)
{
Console.Write("Please input serialize type:(0:none, 1:bin, 2:xml, 3:json, 4: simplebin, 5: struct, 6: customer)");
string strSerializeType = Console.ReadLine();
int serializeType = 0;
int.TryParse(strSerializeType, out serializeType);
ISerialize iSerializer = null;
ISerialize <StructMessage> iStructMessageSerializer = null;
ISerialize <TestMessage> iTestMessageSerializer = null;
switch (serializeType)
{
case 0:
strSerializeType = "none";
break;
case 1:
strSerializeType = "bin";
iSerializer = new BinSerializer();
break;
case 2:
strSerializeType = "xml";
iSerializer = new XMLSerializer(typeof(TestMessage));
break;
case 3:
strSerializeType = "json";
iSerializer = new JsonSerializer(typeof(TestMessage));
break;
case 4:
iSerializer = new SimpleBinSerializer(typeof(TestMessage));
strSerializeType = "simplebin";
break;
case 5:
iStructMessageSerializer = new StructSerializer <StructMessage>();
strSerializeType = "struct";
break;
case 6:
iTestMessageSerializer = new TestMessageSerializer();
strSerializeType = "customer";
break;
default:
serializeType = 0;
strSerializeType = "none";
break;
}
Console.WriteLine("Serialize type is {0}", strSerializeType);
SingleConnectionCable client = new SingleConnectionCable(new IPEndPoint(IPAddress.Parse(_IPAddress), 2500), 7);
client.ReceiveEventHandler += new EventHandler <ReceiveEventArgs>(ReceiveEventHandler);
client.ErrorEventHandler += new EventHandler <ErrorEventArgs>(ErrorEventHandler);
client.RemoteDisconnected += new EventHandler <DisconnectEventArgs>(DisconnectEventHandler);
try
{
client.Connect();
Stopwatch sw = new Stopwatch();
Console.WriteLine("Test async message");
if (serializeType == 0)
{
sw.Start();
try
{
for (int i = 0; i < count; i++)
{
client.AsyncSend(10, buf);
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
sw.Stop();
Console.WriteLine("Finished. Elapse : {0} ms", sw.ElapsedMilliseconds);
}
else
{
TestMessage testMessage = new TestMessage()
{
Id = 1001,
Name = "0123456789",
Data = new byte[buf.Length]
};
StructMessage structMessage = new StructMessage()
{
Id = 1001,
Name = "0123456789",
//Url = "http://www.google.com",
//Site = "google.com",
Data = new byte[4]
};
for (int i = 0; i < testMessage.Data.Length; i++)
{
testMessage.Data[i] = (byte)i;
}
for (int i = 0; i < structMessage.Data.Length; i++)
{
structMessage.Data[i] = (byte)i;
}
sw.Start();
if (serializeType == 5)
{
try
{
for (int i = 0; i < count; i++)
{
client.AsyncSend <StructMessage>((UInt32)(20 + serializeType), ref structMessage, iStructMessageSerializer);
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
else if (serializeType == 6)
{
try
{
for (int i = 0; i < count; i++)
{
client.AsyncSend <TestMessage>((UInt32)(20 + serializeType), ref testMessage, iTestMessageSerializer);
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
else
{
try
{
for (int i = 0; i < count; i++)
{
client.AsyncSend((UInt32)(20 + serializeType), testMessage, iSerializer);
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
sw.Stop();
Console.WriteLine("Finished. Elapse : {0} ms", sw.ElapsedMilliseconds);
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
finally
{
client.Close();
}
}
private async Task ListenAsync()
{
uint headerSize = (uint)Marshal.SizeOf(typeof(MessageHeader));
byte[] headerBuffer = new byte[headerSize];
DataReader reader = new DataReader(_stream.InputStream);
while (true)
{
await reader.LoadAsync(headerSize);
reader.ReadBytes(headerBuffer);
MessageHeader header = StructSerializer.DeserializeStruct <MessageHeader>(headerBuffer);
if (header.Type == MessageType.Telemetry)
{
uint telemetrySize = (uint)Marshal.SizeOf(typeof(TelemetryMessage));
byte[] telemetryBuffer = new byte[telemetrySize - headerSize];
await reader.LoadAsync(telemetrySize - headerSize);
reader.ReadBytes(telemetryBuffer);
var z = new byte[headerBuffer.Length + telemetryBuffer.Length];
headerBuffer.CopyTo(z, 0);
telemetryBuffer.CopyTo(z, headerBuffer.Length);
TelemetryMessage telemetry = StructSerializer.DeserializeStruct <TelemetryMessage>(z);
CurrentValues.Update(telemetry);
Debug.WriteLine("Telemetry");
for (int i = 0; i < TelemetryMessage.EntryLength; i++)
{
Debug.WriteLine(" {0} = {1},{2}", telemetry.Devices[i].Hash, telemetry.Devices[i].IValue, telemetry.Devices[i].DValue);
}
Debug.WriteLine("");
for (int i = 0; i < TelemetryMessage.EntryLength; i++)
{
if (telemetry.Devices[i].Hash == 0)
{
continue;
}
//If we are not watching this hash, ignore it
if (!_telemetry.ContainsKey(telemetry.Devices[i].Hash))
{
continue;
}
ObservableCollection <Data> collection = _telemetry[telemetry.Devices[i].Hash];
object value;
TypeCode type = _telemetryHashToType[telemetry.Devices[i].Hash];
switch (type)
{
case TypeCode.Int32:
value = telemetry.Devices[i].IValue;
break;
case TypeCode.Single:
value = telemetry.Devices[i].DValue;
break;
default:
throw new NotImplementedException();
}
Data data = new Data {
DateTime = DateTime.Now, Value = value
};
CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
collection.Add(data);
});
}
}
}
}
