/// <summary>
/// Creates new XslReader instance with given <see cref="XslCompiledTransform"/>,
/// mode (multithreaded/singlethreaded) and initial buffer size. The buffer will be
/// expanded if necessary to be able to store any element start tag with all its
/// attributes.
/// </summary>
/// <param name="xslTransform">Loaded <see cref="XslCompiledTransform"/> object</param>
/// <param name="multiThread">Defines in which mode (multithreaded or singlethreaded)
/// this instance of XslReader will operate</param>
/// <param name="initialBufferSize">Initial buffer size (number of nodes, not bytes)</param>
public XslReader(XslCompiledTransform xslTransform, bool multiThread, int initialBufferSize)
{
this.xslCompiledTransform = xslTransform;
this.multiThread = multiThread;
this.initialBufferSize = initialBufferSize;
nameTable = new NameTable();
pipe = this.multiThread ? new TokenPipeMultiThread(initialBufferSize) : new TokenPipe(initialBufferSize);
writer = new BufferWriter(pipe, nameTable);
scope = new ScopeManager(nameTable);
SetUndefinedState(ReadState.Initial);
}
/// <summary>
/// Receiver for the combined VAD signal and audio data.
/// </summary>
/// <param name="data">A message containing the combined VAD signal and audio data.</param>
/// <param name="e">The message envelope.</param>
/// <returns>The <see cref="Task"/> representing the asynchronous operation.</returns>
protected override async Task ReceiveAsync(ValueTuple <AudioBuffer, bool> data, Envelope e)
{
byte[] audioData = data.Item1.Data;
bool hasSpeech = data.Item2;
if (this.lastAudioOriginatingTime == default)
{
this.lastAudioOriginatingTime = e.OriginatingTime - data.Item1.Duration;
}
var previousAudioOriginatingTime = this.lastAudioOriginatingTime;
this.lastAudioOriginatingTime = e.OriginatingTime;
// Throw if a fatal error has occurred in the OnConversationError event handler
if (this.fatalError)
{
if (this.conversationError != null)
{
var error = this.conversationError;
this.conversationError = null;
throw error;
}
// Stop processing until the pipeline terminates
return;
}
if (hasSpeech)
{
this.lastAudioContainingSpeechTime = e.OriginatingTime;
bool newSession = false;
if (!this.lastAudioContainedSpeech)
{
// queue a new recognition task
this.currentRecognitionTask = new SpeechRecognitionTask {
SpeechStartTime = previousAudioOriginatingTime
};
this.pendingRecognitionTasks.Enqueue(this.currentRecognitionTask);
// create a new session when sending the first audio packet
newSession = true;
}
// Send the audio data to the cloud
await this.speechRecognitionClient.SendAudioAsync(audioData, this.cancellationTokenSource.Token, newSession);
// Add audio to the current utterance queue so we can reconstruct it in the recognition result later
this.currentQueue.Enqueue(data.DeepClone(this.In.Recycler));
}
// If this is the last audio packet containing speech
if (!hasSpeech && this.lastAudioContainedSpeech)
{
// If this is the first audio packet containing no speech, use the time of the previous audio packet
// as the end of the actual speech, since that is the last packet that contained any speech.
var lastVADSpeechEndTime = this.lastAudioContainingSpeechTime;
// update the latest in-progress recognition
// Allocate a buffer large enough to hold the buffered audio
BufferWriter bw = new BufferWriter(this.currentQueue.Sum(b => b.Item1.Length));
// Get the audio associated with the recognized text from the current queue.
ValueTuple <AudioBuffer, bool> buffer;
while (this.currentQueue.Count > 0)
{
buffer = this.currentQueue.Dequeue();
bw.Write(buffer.Item1.Data);
// We are done with this buffer so enqueue it for recycling
this.In.Recycle(buffer);
}
// Save the buffered audio
this.currentRecognitionTask.Audio = new AudioBuffer(bw.Buffer, this.Configuration.InputFormat);
this.currentRecognitionTask.SpeechEndTime = lastVADSpeechEndTime;
// Call EndAudio to signal that this is the last packet
await this.speechRecognitionClient.SendEndAudioAsync(this.cancellationTokenSource.Token);
}
// Remember last audio state.
this.lastAudioContainedSpeech = hasSpeech;
}
public void Buffer_Write_Numbers()
{
var source = new BufferSlice(new byte[1000], 0, 1000);
// numbers
using (var w = new BufferWriter(source))
{
// max values
w.Write(int.MaxValue);
w.Write(uint.MaxValue);
w.Write(long.MaxValue);
w.Write(double.MaxValue);
w.Write(decimal.MaxValue);
// min values
w.Write(int.MinValue);
w.Write(uint.MinValue);
w.Write(long.MinValue);
w.Write(double.MinValue);
w.Write(decimal.MinValue);
// zero values
w.Write(0); // int
w.Write(0u); // uint
w.Write(0L); // long
w.Write(0d); // double
w.Write(0m); // decimal
// fixed values
w.Write(1990); // int
w.Write(1990u); // uint
w.Write(1990L); // long
w.Write(1990d); // double
w.Write(1990m); // decimal
}
var p = 0;
source.ReadInt32(p).Should().Be(int.MaxValue);
p += 4;
source.ReadUInt32(p).Should().Be(uint.MaxValue);
p += 4;
source.ReadInt64(p).Should().Be(long.MaxValue);
p += 8;
source.ReadDouble(p).Should().Be(double.MaxValue);
p += 8;
source.ReadDecimal(p).Should().Be(decimal.MaxValue);
p += 16;
source.ReadInt32(p).Should().Be(int.MinValue);
p += 4;
source.ReadUInt32(p).Should().Be(uint.MinValue);
p += 4;
source.ReadInt64(p).Should().Be(long.MinValue);
p += 8;
source.ReadDouble(p).Should().Be(double.MinValue);
p += 8;
source.ReadDecimal(p).Should().Be(decimal.MinValue);
p += 16;
source.ReadInt32(p).Should().Be(0);
p += 4;
source.ReadUInt32(p).Should().Be(0u);
p += 4;
source.ReadInt64(p).Should().Be(0L);
p += 8;
source.ReadDouble(p).Should().Be(0d);
p += 8;
source.ReadDecimal(p).Should().Be(0m);
p += 16;
source.ReadInt32(p).Should().Be(1990);
p += 4;
source.ReadUInt32(p).Should().Be(1990u);
p += 4;
source.ReadInt64(p).Should().Be(1990L);
p += 8;
source.ReadDouble(p).Should().Be(1990d);
p += 8;
source.ReadDecimal(p).Should().Be(1990m);
p += 16;
}
private static void Render(ref BufferWriter writer, StructuredReport report)
{
writer.Write(report.ToString());
}
/// <summary>
/// Write transport-specific parameter (port number).
/// </summary>
/// <param name="writer">Buffer writer to which to write.</param>
public void WriteTransportParams(BufferWriter writer)
{
writer.Write(this.port);
}
protected override void WriteXmsHeaders(ref BufferWriter writer, ref GetFileRequest arguments)
{
writer.WriteHeader("x-ms-date", Time, 'R');
writer.WriteHeader("x-ms-version", "2017-04-17");
}
protected virtual void WriteOtherHeaders(ref BufferWriter writer, ref T arguments)
{
writer.WriteHeader("Content-Length", arguments.ContentLength);
writer.WriteHeader("Host", arguments.Client.Host);
}
/// <summary>
/// Wrtie any BsonValue. Use 1 byte for data type, 1 byte for length (optional), 0-255 bytes to value.
/// For document or array, use BufferWriter
/// </summary>
public static void WriteIndexKey(this BufferSlice buffer, BsonValue value, int offset)
{
DEBUG(IndexNode.GetKeyLength(value, true) <= MAX_INDEX_KEY_LENGTH, $"index key must have less than {MAX_INDEX_KEY_LENGTH} bytes");
if (value.IsString)
{
var str = value.AsString;
var strLength = (ushort)Encoding.UTF8.GetByteCount(str);
ExtendedLengthHelper.WriteLength(BsonType.String, strLength, out var typeByte, out var lengthByte);
buffer[offset++] = typeByte;
buffer[offset++] = lengthByte;
buffer.Write(str, offset);
}
else if (value.IsBinary)
{
var arr = value.AsBinary;
ExtendedLengthHelper.WriteLength(BsonType.Binary, (ushort)arr.Length, out var typeByte, out var lengthByte);
buffer[offset++] = typeByte;
buffer[offset++] = lengthByte;
buffer.Write(arr, offset);
}
else
{
buffer[offset++] = (byte)value.Type;
switch (value.Type)
{
case BsonType.Null:
case BsonType.MinValue:
case BsonType.MaxValue:
break;
case BsonType.Int32: buffer.Write(value.AsInt32, offset); break;
case BsonType.Int64: buffer.Write(value.AsInt64, offset); break;
case BsonType.Double: buffer.Write(value.AsDouble, offset); break;
case BsonType.Decimal: buffer.Write(value.AsDecimal, offset); break;
case BsonType.Document:
using (var w = new BufferWriter(buffer))
{
w.Skip(offset); // skip offset from buffer
w.WriteDocument(value.AsDocument, true);
}
break;
case BsonType.Array:
using (var w = new BufferWriter(buffer))
{
w.Skip(offset); // skip offset from buffer
w.WriteArray(value.AsArray, true);
}
break;
case BsonType.ObjectId: buffer.Write(value.AsObjectId, offset); break;
case BsonType.Guid: buffer.Write(value.AsGuid, offset); break;
case BsonType.Boolean: buffer[offset] = (value.AsBoolean) ? (byte)1 : (byte)0; break;
case BsonType.DateTime: buffer.Write(value.AsDateTime, offset); break;
default: throw new NotImplementedException();
}
}
}
private void MetaClientBackground()
{
Guid guid = Guid.Empty;
try
{
var metaClient = new TcpClient();
metaClient.Connect(this.host, this.port);
var metaStream = metaClient.GetStream();
// send protocol version and replay interval
var buffer = new byte[256];
var writer = new BufferWriter(buffer);
writer.Write(RemoteExporter.ProtocolVersion);
writer.Write(this.replayRemoteLatestStart ? -1 : this.replayStart);
writer.Write(this.replayEnd);
metaStream.Write(writer.Buffer, 0, writer.Position);
// receive ID and transport info
var reader = new BufferReader(buffer);
Transport.Read(reader.Buffer, 4, metaStream);
var len = reader.ReadInt32();
reader.Reset(len);
Transport.Read(reader.Buffer, len, metaStream);
var id = new byte[16];
reader.Read(id, id.Length);
var transport = Transport.TransportOfName(reader.ReadString());
transport.ReadTransportParams(reader);
guid = new Guid(id);
Trace.WriteLine($"RemoteImporter meta client connected (ID={guid})");
// process metadata updates
while (!this.disposed)
{
reader.Reset(sizeof(int));
Transport.Read(reader.Buffer, sizeof(int), metaStream);
var metalen = reader.ReadInt32();
if (metalen > 0)
{
reader.Reset(metalen);
Transport.Read(reader.Buffer, metalen, metaStream);
var meta = Metadata.Deserialize(reader);
if (meta.Kind == MetadataKind.StreamMetadata)
{
try
{
this.storeWriter.OpenStream((PsiStreamMetadata)meta);
}
catch (Exception ex)
{
Trace.TraceError($"RemoteImporter meta update duplicate stream - expected after reconnect (Name={meta.Name}, ID={guid}, Error={ex.Message})");
}
}
else
{
this.storeWriter.WriteToCatalog(meta);
}
Trace.WriteLine($"RemoteImporter meta update (Name={meta.Name}, ID={guid})");
}
else
{
// "intermission" in meta updates
this.Importer = this.importerThunk(this.storeWriter.Name); // now that we have a populated catalog
this.StartDataClient(guid, transport);
this.connected.Set();
}
}
}
catch (Exception ex)
{
Trace.WriteLine($"RemoteImporter meta connection error (Message={ex.Message}, ID={guid})");
this.StartMetaClient(); // restart
}
}
public void PsiStreamMetadataTest()
{
var messageCount = 42L;
var avgMessageSize = 1234L;
var avgLatency = 70000L;
var messageSizeCumulativeSum = messageCount * avgMessageSize;
var latencyCumulativeSum = messageCount * avgLatency;
// serialize manually, simulating older/newer versions
(byte[] Buffer, int Size) Serialize(int version, bool isPolymorphic)
{
var writer = new BufferWriter(0);
writer.Write("SomeName"); // Name
writer.Write(123); // ID
writer.Write("SomeFakeTypeName"); // TypeName
writer.Write(version); // Version
writer.Write("SomeFakeSerializerTypeName"); // SerializerTypeName
writer.Write(7); // SerializerVersion
writer.Write((ushort)(isPolymorphic ? StreamMetadataFlags.Polymorphic : 0)); // CustomFlags
writer.Write((ushort)MetadataKind.StreamMetadata); // MetadataKind
writer.Write(new DateTime(1969, 4, 2)); // OpenedTime
writer.Write(new DateTime(2070, 1, 1)); // ClosedTime
if (version > 1)
{
writer.Write(messageCount); // MessageCount
writer.Write(messageSizeCumulativeSum); // MessageSizeCumulativeSum
writer.Write(latencyCumulativeSum); // LatencyCumulativeSum
}
else
{
writer.Write((int)messageCount); // MessageCount
}
writer.Write(new DateTime(1971, 11, 3)); // FirstMessageCreationTime
writer.Write(new DateTime(1972, 10, 12)); // LastMessageCreationTime
writer.Write(new DateTime(1971, 2, 3)); // FirstMessageOriginatingTime
writer.Write(new DateTime(1972, 1, 12)); // LastMessageOriginatingTime
if (version <= 1)
{
writer.Write((int)avgMessageSize); // AverageMessageSize
writer.Write((int)avgLatency / 10); // AverageLatency in *microseconds*
}
if (isPolymorphic)
{
writer.Write(2); // RuntimeTypes.Count
writer.Write(1); // Key
writer.Write("SomeFakePolyType1"); // Value
writer.Write(2); // Key
writer.Write("SomeFakePolyType2"); // Value
}
if (version > 0)
{
var payload = new byte[] { 1, 2, 3 };
writer.Write(payload.GetType().FullName); // SupplementalMetadataTypeName
writer.Write(payload.Length + 4 /* prefix */ + 4 /* length */); // supplementalMetadataBytes.Length
writer.Write(SerializationHandler.RefPrefixNew);
writer.Write(payload.Length);
writer.Write(payload); // bytes
}
return(writer.Buffer, writer.Size);
}
// verify all versions deserialize/serialize correctly with migration to latest version
void TestAllVersions(Action <PsiStreamMetadata> verify)
{
// verify metadata instance
void VerifyMeta(PsiStreamMetadata meta, int version, bool isPolymorphic)
{
verify(meta);
Assert.AreEqual(isPolymorphic, meta.IsPolymorphic);
if (isPolymorphic)
{
Assert.AreEqual(2, meta.RuntimeTypes.Count);
Assert.AreEqual("SomeFakePolyType1", meta.RuntimeTypes[1]);
Assert.AreEqual("SomeFakePolyType2", meta.RuntimeTypes[2]);
}
Assert.AreEqual(2, meta.Version); // expect upgraded version
if (version > 0)
{
var expected = new byte[] { 1, 2, 3 };
Assert.AreEqual(expected.GetType().FullName, meta.SupplementalMetadataTypeName);
Assert.IsTrue(Enumerable.SequenceEqual(expected, meta.GetSupplementalMetadata <byte[]>()));
}
else
{
Assert.AreEqual(null, meta.SupplementalMetadataTypeName);
}
}
// verify with isPolymorphic=true/false and versions=0..2
for (var pass = 0; pass < 2; pass++)
{
var isPolymorphic = pass > 0;
for (var version = 0; version < 3; version++)
{
// manually serialize (including older formats)
var(buffer, size) = Serialize(version, isPolymorphic);
var reader = new BufferReader(buffer, size);
var meta = (PsiStreamMetadata)Metadata.Deserialize(reader);
VerifyMeta(meta, version, isPolymorphic);
// test serialization via round-trip
var writer = new BufferWriter(0);
meta.Serialize(writer);
var roundtrip = (PsiStreamMetadata)Metadata.Deserialize(new BufferReader(writer));
VerifyMeta(roundtrip, version, isPolymorphic);
}
}
}
TestAllVersions(meta =>
{
Assert.AreEqual("SomeName", meta.Name);
Assert.AreEqual(123, meta.Id);
Assert.AreEqual(123, meta.Id);
Assert.AreEqual("SomeFakeTypeName", meta.TypeName);
Assert.AreEqual("SomeFakeSerializerTypeName", meta.SerializerTypeName);
Assert.AreEqual(7, meta.SerializerVersion);
Assert.AreEqual(new DateTime(1969, 4, 2), meta.OpenedTime);
Assert.AreEqual(new DateTime(2070, 1, 1), meta.ClosedTime);
Assert.AreEqual(messageCount, meta.MessageCount);
Assert.AreEqual(messageSizeCumulativeSum, meta.MessageSizeCumulativeSum);
Assert.AreEqual(latencyCumulativeSum, meta.LatencyCumulativeSum);
Assert.AreEqual(new DateTime(1971, 11, 3), meta.FirstMessageCreationTime);
Assert.AreEqual(new DateTime(1972, 10, 12), meta.LastMessageCreationTime);
Assert.AreEqual(new DateTime(1971, 2, 3), meta.FirstMessageOriginatingTime);
Assert.AreEqual(new DateTime(1972, 1, 12), meta.LastMessageOriginatingTime);
Assert.AreEqual(avgMessageSize, meta.AverageMessageSize);
Assert.AreEqual(avgLatency / TimeSpan.TicksPerMillisecond, meta.AverageMessageLatencyMs);
});
}
/// <summary>
/// Consumes the <paramref name="stream"/> to the end into a <see cref="BufferWriter"/> and disposes the stream.
/// </summary>
/// <param name="stream"></param>
/// <param name="ct"></param>
/// <returns></returns>
public static ValueTask <BufferWriter> Consume(this Stream stream, CancellationToken ct = default) // TODO dispose stream?
{
const int minReadCapacity = 1024;
var knownSize = -1;
if (stream.CanSeek)
{
knownSize = checked ((int)stream.Length);
}
var bw = BufferWriter.Create(knownSize);
// ReSharper disable RedundantAssignment
ValueTask <int> t = default;
bool finishSync = false;
// ReSharper restore RedundantAssignment
#if NETCOREAPP
while (true)
{
bw.EnsureCapacity(minReadCapacity);
t = stream.ReadAsync(bw.FreeMemory, ct);
if (t.IsCompletedSuccessfully)
{
bw.Advance(t.Result);
if (t.Result == 0 || (knownSize >= 0 && t.Result == knownSize))
{
stream.Dispose();
return(new ValueTask <BufferWriter>(bw));
}
// Continue, we do not know the size or have read partially. Cannot tell that at the end of stream until ReadAsync returns 0.
}
else
{
finishSync = true;
break;
}
}
#endif
return(ConsumeAsync());
async ValueTask <BufferWriter> ConsumeAsync()
{
byte[] tempBuff = null;
try
{
do
{
if (finishSync)
{
#if NETCOREAPP
await t;
#endif
// we have written to free memory but not advanced yet
bw.Advance(t.Result);
if (t.Result == 0 || (knownSize >= 0 && t.Result == knownSize))
{
return(bw);
}
}
bw.EnsureCapacity(minReadCapacity);
#if NETCOREAPP
t = stream.ReadAsync(bw.FreeMemory, ct);
#else
if (tempBuff == null)
{
tempBuff = BufferPool <byte> .Rent(bw.FreeCapacity);
}
var bytesRead = await stream.ReadAsync(tempBuff, 0, tempBuff.Length, ct);
if (bytesRead > 0)
{
tempBuff.AsSpan().Slice(0, bytesRead).CopyTo(bw.FreeSpan);
}
t = new ValueTask <int>(bytesRead);
#endif
finishSync = true;
} while (true);
}
finally
{
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
if (tempBuff != null)
{
BufferPool <byte> .Return(tempBuff);
}
stream.Dispose();
}
}
}
public void PocoPerfSerialize()
{
int iter = 100000;
Poco poco = new Poco();
poco.DateProp = DateTime.Now;
poco.IntProp = 100;
poco.GuidProp = Guid.NewGuid();
poco.StringProp = "test data";
// byte[] is a baseline to compare with
BufferWriter bw = new BufferWriter(256);
var sc = new SerializationContext();
Serializer.Serialize(bw, poco, sc);
int byteSize = bw.Position;
byte[] bytes = new byte[byteSize];
Serializer.Serialize(bw, bytes, sc);
BufferReader br = new BufferReader(bw.Buffer);
Poco poco2 = new Poco();
Serializer.Deserialize(br, ref poco2, sc);
byte[] bytes2 = new byte[byteSize];
Serializer.Deserialize(br, ref bytes2, sc);
sc.Reset();
// baseline
Stopwatch sw = Stopwatch.StartNew();
for (int i = 0; i < iter; i++)
{
bw.Reset();
Serializer.Serialize(bw, bytes, sc);
sc.Reset();
}
for (int i = 0; i < iter; i++)
{
br.Reset();
Serializer.Deserialize(br, ref bytes2, sc);
sc.Reset();
}
sw.Stop();
Console.WriteLine($"Baseline (byte[{byteSize}]): {sw.ElapsedMilliseconds * 1000000d / iter} nanoseconds per serialization + deserialization");
// POCO test
sw = Stopwatch.StartNew();
for (int i = 0; i < iter; i++)
{
bw.Reset();
Serializer.Serialize(bw, poco, sc);
sc.Reset();
}
for (int i = 0; i < iter; i++)
{
br.Reset();
Serializer.Deserialize(br, ref poco2, sc);
sc.Reset();
}
sw.Stop();
Console.WriteLine($"Simple object (poco): {sw.ElapsedMilliseconds * 1000000d / iter} nanoseconds per serialization + deserialization");
Console.WriteLine($"{iter / (sw.ElapsedMilliseconds / 1000d)} roundtrip operations per second");
Assert.AreEqual(poco.StringProp, poco2.StringProp);
Assert.AreEqual(poco.DateProp, poco2.DateProp);
Assert.AreEqual(poco.IntProp, poco2.IntProp);
Assert.AreEqual(poco.GuidProp, poco2.GuidProp);
}
public int Write(BufferWriter buffer, Envelope envelope)
{
return(this.Write(envelope, buffer.Buffer, 0, buffer.Position));
}
public void BufferTest()
{
BufferWriter bufW = new BufferWriter(2); // force reallocations
byte b = 5;
byte[] br = new byte[] { 1, 2, 3 };
char c = 'A';
char[] cr = new char[] { 'A', 'B', 'C' };
string str = "a string";
double d = 1.1;
double[] dr = new double[] { 1.1, 2.2, 3.3 };
float f = 0.1f;
float[] fr = new float[] { 0.1f, 0.01f, 0.001f };
int i = 0x0FF00FFF;
int[] ir = new[] { 0x0FF00FF0, 0x0FF00FF1, 0x0FF00FF2 };
short s = 0x0FFF;
short[] sr = new short[] { 0x0FF0, 0x0FF1, 0x0FF2 };
long l = 0x00FFFF0000EEEE0F;
long[] lr = new long[] { 0x00FFFF0000EEEE00, 0x00FFFF0000EEEE01, 0x00FFFF0000EEEE02 };
ushort us = 0xFFFF;
uint ui = 0xFFFFFFFF;
ulong ul = 0xFFFFFFFFFFFFFFFF;
DateTime dt = DateTime.UtcNow;
var stream = new MemoryStream(new byte[] { 1, 2, 3, 4, 5 });
bufW.Write(b);
bufW.Write(br);
bufW.Write(c);
bufW.Write(cr);
bufW.Write(str);
bufW.Write(d);
bufW.Write(dr);
bufW.Write(f);
bufW.Write(fr);
bufW.Write(i);
bufW.Write(ir);
bufW.Write(s);
bufW.Write(sr);
bufW.Write(l);
bufW.Write(lr);
bufW.Write(us);
bufW.Write(ui);
bufW.Write(ul);
bufW.Write(dt);
bufW.CopyFromStream(stream, 2);
bufW.CopyFromStream(stream, 3);
int position = bufW.Position;
bufW.CopyFromStream(stream, 2); // attempt to read past end of stream
Assert.AreEqual(position, bufW.Position);
BufferReader bufR = new BufferReader(bufW.Buffer);
Assert.AreEqual(b, bufR.ReadByte());
var br_r = new byte[br.Length];
bufR.Read(br_r, br.Length);
Assert.IsTrue(Enumerable.SequenceEqual(br, br_r));
Assert.AreEqual(c, bufR.ReadChar());
var cr_r = new char[cr.Length];
bufR.Read(cr_r, cr.Length);
Assert.IsTrue(Enumerable.SequenceEqual(cr, cr_r));
Assert.AreEqual(str, bufR.ReadString());
Assert.AreEqual(d, bufR.ReadDouble());
var dr_r = new double[dr.Length];
bufR.Read(dr_r, dr.Length);
Assert.IsTrue(Enumerable.SequenceEqual(dr, dr_r));
Assert.AreEqual(f, bufR.ReadSingle());
var fr_r = new float[fr.Length];
bufR.Read(fr_r, fr.Length);
Assert.IsTrue(Enumerable.SequenceEqual(fr, fr_r));
Assert.AreEqual(i, bufR.ReadInt32());
var ir_r = new int[ir.Length];
bufR.Read(ir_r, ir.Length);
Assert.IsTrue(Enumerable.SequenceEqual(ir, ir_r));
Assert.AreEqual(s, bufR.ReadInt16());
var sr_r = new short[sr.Length];
bufR.Read(sr_r, sr.Length);
Assert.IsTrue(Enumerable.SequenceEqual(sr, sr_r));
Assert.AreEqual(l, bufR.ReadInt64());
var lr_r = new long[lr.Length];
bufR.Read(lr_r, lr.Length);
Assert.IsTrue(Enumerable.SequenceEqual(lr, lr_r));
Assert.AreEqual(us, bufR.ReadUInt16());
Assert.AreEqual(ui, bufR.ReadUInt32());
Assert.AreEqual(ul, bufR.ReadUInt64());
Assert.AreEqual(dt, bufR.ReadDateTime());
var stream_r = new MemoryStream();
bufR.CopyToStream(stream_r, (int)stream.Length);
CollectionAssert.AreEqual(stream.ToArray(), stream_r.ToArray());
}
public void WriteTo(BufferWriter writer, int index, int length) {
int limit = index + length;
if (limit > _text.Length)
limit = _text.Length;
WriteToInternal(writer, index, limit);
}
public void WriteTo(ref BufferWriter <byte> writer)
{
writer.WriteVarArray(Headers);
}
// The untyped interface methods call the inner serializer directly (bypassing the handler methods) // to avoid writing and reading a second prefix internal override void UntypedSerialize(BufferWriter writer, object instance, SerializationContext context) => this.innerSerializer.Serialize(writer, (T)instance, context);
public void Write(BufferWriter bufferWriter)
{
this.ReserveBlock(bufferWriter.Position);
this.WriteToBlock(bufferWriter.Buffer, 0, bufferWriter.Position);
this.CommitBlock();
}
protected abstract void WriteXmsHeaders(ref BufferWriter writer, ref T arguments);
public void WriteTo(BufferWriter writer, int index)
{
WriteToInternal(writer, index, _text.Length);
}
public void Serialize(BufferWriter writer, T instance, SerializationContext context)
{
this.serializeImpl(writer, instance, context);
}
/// <summary>
/// Receiver for the combined VAD signal and audio data.
/// </summary>
/// <param name="data">A message containing the combined VAD signal and audio data.</param>
/// <param name="e">The message envelope</param>
/// <returns>The <see cref="Task"/> representing the asynchronous operation.</returns>
protected override async Task ReceiveAsync(ValueTuple <AudioBuffer, bool> data, Envelope e)
{
byte[] audioData = data.Item1.Data;
bool hasSpeech = data.Item2;
this.lastAudioOriginatingTime = e.OriginatingTime;
// Throw if a fatal error has occurred in the OnConversationError event handler
if (this.fatalError)
{
if (this.conversationError != null)
{
var error = this.conversationError;
this.conversationError = null;
throw error;
}
// Stop processing until the pipeline terminates
return;
}
if (hasSpeech || this.lastAudioContainedSpeech)
{
// Send the audio data to the cloud
await this.speechRecognitionClient.SendAudioAsync(audioData, this.cancellationTokenSource.Token);
// Add audio to the current utterance queue so we can reconstruct it in the recognition result later
this.currentQueue.Enqueue(data.DeepClone(this.In.Recycler));
}
// If this is the last audio packet containing speech
if (!hasSpeech && this.lastAudioContainedSpeech)
{
this.lastVADSpeechEndTime = e.OriginatingTime;
this.lastVADSpeechTimeInterval = new TimeInterval(this.lastVADSpeechStartTime, this.lastVADSpeechEndTime);
// Allocate a buffer large enough to hold the buffered audio
BufferWriter bw = new BufferWriter(this.currentQueue.Sum(b => b.Item1.Length));
// Get the audio associated with the recognized text from the current queue.
ValueTuple <AudioBuffer, bool> buffer;
while (this.currentQueue.TryDequeue(out buffer))
{
bw.Write(buffer.Item1.Data);
// We are done with this buffer so enqueue it for recycling
this.In.Recycle(buffer);
}
// Save the buffered audio
this.lastAudioBuffer = bw.Buffer;
// Call EndAudio to signal that this is the last packet
await this.speechRecognitionClient.SendEndAudioAsync(this.cancellationTokenSource.Token);
}
else if (hasSpeech && !this.lastAudioContainedSpeech)
{
// If this is the first audio packet containing speech
this.lastVADSpeechStartTime = e.OriginatingTime;
// Also post a null partial recognition result
this.lastPartialResult = string.Empty;
this.PartialRecognitionResults.Post(this.BuildPartialSpeechRecognitionResult(this.lastPartialResult), e.OriginatingTime);
}
// Remember last audio state.
this.lastAudioContainedSpeech = hasSpeech;
}
public void Serialize(BufferWriter writer, MemoryStream instance, SerializationContext context)
{
this.innerSerializer.Serialize(writer, instance, context);
}
private static void PlainText(ref BufferWriter <WriterAdapter> writer, ReadOnlySpan <byte> body)
{
writer.Write(body);
}
/// <summary>
/// Wrtie any BsonValue. Use 1 byte for data type, 1 byte for length (optional), 0-255 bytes to value.
/// For document or array, use BufferWriter
/// </summary>
public static void WriteIndexKey(this BufferSlice buffer, BsonValue value, int offset)
{
ENSURE(value.GetBytesCount(false) < 255, "index key must have less than 255 bytes");
buffer[offset++] = (byte)value.Type;
switch (value.Type)
{
case BsonType.Null:
case BsonType.MinValue:
case BsonType.MaxValue:
break;
case BsonType.Int32: buffer.Write(value.AsInt32, offset); break;
case BsonType.Int64: buffer.Write(value.AsInt64, offset); break;
case BsonType.Double: buffer.Write(value.AsDouble, offset); break;
case BsonType.Decimal: buffer.Write(value.AsDecimal, offset); break;
case BsonType.String:
var str = value.AsString;
var strLength = (byte)Encoding.UTF8.GetByteCount(str);
buffer[offset++] = strLength;
buffer.Write(str, offset);
break;
case BsonType.Document:
using (var w = new BufferWriter(buffer))
{
w.Skip(offset); // skip offset from buffer
w.WriteDocument(value.AsDocument, true);
}
break;
case BsonType.Array:
using (var w = new BufferWriter(buffer))
{
w.Skip(offset); // skip offset from buffer
w.WriteArray(value.AsArray, true);
}
break;
case BsonType.Binary:
var arr = value.AsBinary;
buffer[offset++] = (byte)arr.Length;
buffer.Write(arr, offset);
break;
case BsonType.ObjectId: buffer.Write(value.AsObjectId, offset); break;
case BsonType.Guid: buffer.Write(value.AsGuid, offset); break;
case BsonType.Boolean: buffer[offset] = (value.AsBoolean) ? (byte)1 : (byte)0; break;
case BsonType.DateTime: buffer.Write(value.AsDateTime, offset); break;
default: throw new NotImplementedException();
}
}
/// <inheritdoc />
public void Serialize(BufferWriter writer, Dictionary <TKey, TValue> instance, SerializationContext context)
{
this.comparerHandler.Serialize(writer, instance.Comparer, context);
this.entriesHandler.Serialize(writer, instance.ToArray(), context);
}
private void TestMemoryStreamSerialization(MemoryStream source)
{
var expectedValues = source.ToArray();
// serialize the source
var bw = new BufferWriter(0);
Serializer.Serialize(bw, source, new SerializationContext());
// verify serialized length matches the source data length (+ refHeader + dataLength)
Assert.AreEqual(source.Length + 8, bw.Position);
// deserialize into default target
var br = new BufferReader(bw.Buffer);
var target = default(MemoryStream);
Serializer.Deserialize(br, ref target, new SerializationContext());
CollectionAssert.AreEqual(expectedValues, target.ToArray());
Assert.AreEqual(source.Length, target.Length);
Assert.AreEqual(source.Length, target.Capacity);
// deserialize into target with expandable capacity
br = new BufferReader(bw.Buffer);
target = new MemoryStream();
Serializer.Deserialize(br, ref target, new SerializationContext());
CollectionAssert.AreEqual(expectedValues, target.ToArray());
Assert.AreEqual(source.Length, target.Length);
// deserialize into target with existing data
br = new BufferReader(bw.Buffer);
target = new MemoryStream();
target.Write(new byte[] { 1, 2, 3, 4, 5 });
Serializer.Deserialize(br, ref target, new SerializationContext());
CollectionAssert.AreEqual(expectedValues, target.ToArray());
Assert.AreEqual(source.Length, target.Length);
// deserialize into target with fixed capacity >> length
br = new BufferReader(bw.Buffer);
target = new MemoryStream(new byte[1000]);
Serializer.Deserialize(br, ref target, new SerializationContext());
CollectionAssert.AreEqual(expectedValues, target.ToArray());
Assert.AreEqual(source.Length, target.Length);
Assert.AreEqual(1000, target.Capacity); // original capacity preserved
// deserialize into target with fixed and insufficient capacity
br = new BufferReader(bw.Buffer);
target = new MemoryStream(new byte[1]);
try
{
Serializer.Deserialize(br, ref target, new SerializationContext());
Assert.Fail("Expected exception was not thrown");
}
catch (Exception e)
{
Assert.IsInstanceOfType(e, typeof(NotSupportedException));
}
// deserialize into read-only target
br = new BufferReader(bw.Buffer);
target = new MemoryStream(new byte[source.Length], writable: false);
try
{
Serializer.Deserialize(br, ref target, new SerializationContext());
Assert.Fail("Expected exception was not thrown");
}
catch (Exception e)
{
Assert.IsInstanceOfType(e, typeof(NotSupportedException));
}
}
/// <inheritdoc />
public void Serialize(BufferWriter writer, Dictionary <TKey, TValue> instance, SerializationContext context)
{
this.innerSerializer.Serialize(writer, instance, context);
}
internal HubReader(BufferWriter bufferWriter)
{
_bufferWriter = bufferWriter;
}
public void Serialize(BufferWriter writer, Shared <T> instance, SerializationContext context)
{
this.handler.Serialize(writer, instance.inner, context);
}
public void WriteTo(BufferWriter writer, int index) {
WriteToInternal(writer, index, _text.Length);
}
public override void WriteTransactionData(ref BufferWriter <byte> writer)
{
writer.WriteLittleEndian(Nonce);
}
private void WriteToInternal(BufferWriter writer, int index, int limit) {
char[] temp = GetInternalTemporaryBufferForCopy();
// Note: must be temp.Length >= limit here
int tempIndex = 0;
for (int i = index; i < limit; i++) {
char ch = _text[i];
if (ch == '\0')
break;
if (ch != WIDECHAR_PAD)
temp[tempIndex++] = ch;
}
if (writer != null)
writer(temp, tempIndex);
}
public static int WriteItem <T>(BufferWriter bufferWriter, in T value)
