public static async ValueTask <WrxPacket> ReadAsync(IAsyncSimpleInputStream <byte> stream, CancellationToken cancellationToken = default)
{
WrxPacket packet;
ushort crc;
await using (var crcStream = Crc16.CcittFalse.Wrap(stream, leaveBaseUndisposed: true))
{
packet = await crcStream.ReadByteAsync(cancellationToken).ConfigureAwait(false) switch
{
0 => await ReadProtocol0Async(crcStream, cancellationToken).ConfigureAwait(false),
1 => await ReadProtocol1Async(crcStream, cancellationToken).ConfigureAwait(false),
_ => throw new Exception(),
};
crc = crcStream.Crc;
}
if (await stream.ReadUInt16LittleEndianAsync(cancellationToken).ConfigureAwait(false) != crc)
{
packet.Dispose();
throw new Exception("CRC verification failed.");
}
return(packet);
}
private static async ValueTask PreReadAsync(IAsyncSimpleInputStream <byte> stream, CancellationToken cancellationToken)
{
if (await stream.ReadByteAsync(cancellationToken) != 0xC0)
{
throw new Exception();
}
}
public WrxCommandClient(
IAsyncSimpleOutputStream <byte> requestStream,
IAsyncSimpleInputStream <byte> responseStream,
ArrayPool <byte> byteArrayPool,
bool doNotDisposeRequestStream = false,
bool doNotDisposeResponseStream = false) :
this(
new WrxPacketWriter(requestStream, doNotDisposeRequestStream),
new WrxPacketReader(responseStream, doNotDisposeResponseStream),
byteArrayPool)
{
}
public WrxCommandServer(
IAsyncSimpleInputStream <byte> requestStream,
IAsyncSimpleOutputStream <byte> responseStream,
IAsyncWrxCommandHandler commandHandler,
bool doNotDisposeRequestStream = false,
bool doNotDisposeResponseStream = false) :
this(
new WrxPacketReader(requestStream, doNotDisposeRequestStream),
new WrxPacketWriter(responseStream, doNotDisposeResponseStream),
commandHandler,
ArrayPool <byte> .Shared)
{
}
public WrxCommandClient(
IAsyncSimpleOutputStream <byte> requestStream,
IAsyncSimpleInputStream <byte> responseStream,
bool doNotDisposeRequestStream = false,
bool doNotDisposeResponseStream = false) :
this(
requestStream,
responseStream,
ArrayPool <byte> .Shared,
doNotDisposeRequestStream,
doNotDisposeResponseStream)
{
}
public static async ValueTask <byte> ReadByteAsync(this IAsyncSimpleInputStream <byte> stream, ArrayPool <byte> arrayPool, CancellationToken cancellationToken = default)
{
var array = arrayPool.Rent(1);
try
{
await stream.ReadFullyAsync(array.AsMemory(..1)).ConfigureAwait(false);
return(array[0]);
}
finally
{
arrayPool.Return(array);
}
}
public static async ValueTask <TResult> ReadPacketAsync <TResult>(
IAsyncSimpleInputStream <byte> stream,
Func <IAsyncSimpleInputStream <byte>, CancellationToken, ValueTask <TResult> > callback,
CancellationToken cancellationToken = default)
{
await PreReadAsync(stream, cancellationToken).ConfigureAwait(false);
await using var packetStream = new PacketInputStream(stream);
try
{
return(await callback(packetStream, cancellationToken).ConfigureAwait(false));
}
finally
{
await PostReadAsync(packetStream, cancellationToken).ConfigureAwait(false);
}
}
public static SimpleCrcInputStream <T> Wrap <T>(this CrcParameters <T> parameters, IAsyncSimpleInputStream <byte> @base, bool leaveBaseUndisposed = false)
{
return(new SimpleCrcInputStream <T>(@base, parameters, leaveBaseUndisposed));
}
internal PacketInputStream(IAsyncSimpleInputStream <byte> @base)
{
_base = @base;
}
private static async ValueTask <WrxPacket> ReadCommonAsync(int protocol, WrxPacketAction action, int command, int dataLength, IAsyncSimpleInputStream <byte> stream, CancellationToken cancellationToken)
{
var data = ArrayPool <byte> .Shared.Rent(dataLength);
await stream.ReadFullyAsync(data.AsMemory(..dataLength), cancellationToken).ConfigureAwait(false);
return(new WrxPacket(protocol, action, command, data.AsMemory(..dataLength), OnDispose, data));
public WrxPacketReader(IAsyncSimpleInputStream <byte> @base, bool leaveBaseUndisposed = false) :
base(@base, leaveBaseUndisposed)
{
}
public SimpleCrcInputStream(IAsyncSimpleInputStream <byte> @base, CrcCalculator <T> crcCalculator, bool leaveBaseUndisposed = false) :
base(@base, leaveBaseUndisposed)
{
CrcCalculator = crcCalculator;
}
public SimpleCrcInputStream(IAsyncSimpleInputStream <byte> @base, CrcParameters <T> crcParameters, bool leaveBaseUndisposed = false) :
this(@base, crcParameters.CreateCalculator(), leaveBaseUndisposed)
{
}
public static async ValueTask ReadFullyAsync <T>(this IAsyncSimpleInputStream <T> stream, Memory <T> buffer, CancellationToken cancellationToken = default)
{
for (int index = 0, count; index < buffer.Length; index += count)
{
count = await stream.ReadAsync(buffer[index..], cancellationToken).ConfigureAwait(false);
public static ValueTask <byte> ReadByteAsync(this IAsyncSimpleInputStream <byte> stream, CancellationToken cancellationToken = default)
{
return(stream.ReadByteAsync(ArrayPool <byte> .Shared, cancellationToken));
}
