private static void UnpackToCore(Unpacker unpacker, int count, MessagePackObjectDictionary collection)
{
for (int i = 0; i < count; i++)
{
if (!unpacker.Read())
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
var key = unpacker.LastReadData;
if (!unpacker.Read())
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
if (unpacker.IsCollectionHeader)
{
MessagePackObject value;
if (!unpacker.UnpackSubtreeDataCore(out value))
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
collection.Add(key, value);
}
else
{
collection.Add(key, unpacker.LastReadData);
}
}
}
public static T Decode <T>(Unpacker unpacker, Func <string, Type> typeFinder, Func <Type, Unpacker, T> unpacking)
{
if (!unpacker.IsArrayHeader || UnpackHelpers.GetItemsCount(unpacker) != 2)
{
throw SerializationExceptions.NewUnknownTypeEmbedding();
}
using (var subTreeUnpacker = unpacker.ReadSubtree())
{
string typeCode;
if (!subTreeUnpacker.ReadString(out typeCode))
{
SerializationExceptions.ThrowUnexpectedEndOfStream(subTreeUnpacker);
}
var type = typeFinder(typeCode);
if (!subTreeUnpacker.Read())
{
SerializationExceptions.ThrowUnexpectedEndOfStream(subTreeUnpacker);
}
return(unpacking(type, subTreeUnpacker));
}
}
protected internal override async Task <T> UnpackFromAsyncCore(Unpacker unpacker, CancellationToken cancellationToken)
{
if (!unpacker.IsArrayHeader)
{
SerializationExceptions.ThrowIsNotArrayHeader(unpacker);
}
var buffer = new TItem[UnpackHelpers.GetItemsCount(unpacker)];
using (var subTreeUnpacker = unpacker.ReadSubtree())
{
// Reverse Order
for (int i = buffer.Length - 1; i >= 0; i--)
{
if (!await subTreeUnpacker.ReadAsync(cancellationToken).ConfigureAwait(false))
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
buffer[i] = await this._itemSerializer.UnpackFromAsync(subTreeUnpacker, cancellationToken).ConfigureAwait(false);
}
}
return(Factory(buffer));
}
public static async Task <T> DecodeAsync <T>(Unpacker unpacker, Func <string, Type> typeFinder, Func <Type, Unpacker, CancellationToken, Task <object> > unpackingAsync, CancellationToken cancellationToken)
{
if (!unpacker.IsArrayHeader || UnpackHelpers.GetItemsCount(unpacker) != 2)
{
throw SerializationExceptions.NewUnknownTypeEmbedding();
}
using (var subTreeUnpacker = unpacker.ReadSubtree())
{
var typeCode = await subTreeUnpacker.ReadStringAsync(cancellationToken).ConfigureAwait(false);
if (!typeCode.Success)
{
SerializationExceptions.ThrowUnexpectedEndOfStream(subTreeUnpacker);
}
var type = typeFinder(typeCode.Value);
if (!await subTreeUnpacker.ReadAsync(cancellationToken).ConfigureAwait(false))
{
SerializationExceptions.ThrowUnexpectedEndOfStream(subTreeUnpacker);
}
return((T) await unpackingAsync(type, subTreeUnpacker, cancellationToken).ConfigureAwait(false));
}
}
protected internal override Complex UnpackFromCore(Unpacker unpacker)
{
if (!unpacker.IsArrayHeader)
{
SerializationExceptions.ThrowInvalidArrayItemsCount(unpacker, typeof(Complex), 2);
}
long length = UnpackHelpers.GetItemsCount(unpacker);
if (length != 2)
{
SerializationExceptions.ThrowInvalidArrayItemsCount(unpacker, typeof(Complex), 2);
}
double real, imaginary;
if (!unpacker.ReadDouble(out real))
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
if (!unpacker.ReadDouble(out imaginary))
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
return(new Complex(real, imaginary));
}
protected internal override T UnpackFromCore(Unpacker unpacker)
{
if (!unpacker.IsArrayHeader)
{
SerializationExceptions.ThrowIsNotArrayHeader(unpacker);
}
var buffer = new TItem[UnpackHelpers.GetItemsCount(unpacker)];
using (var subTreeUnpacker = unpacker.ReadSubtree())
{
// Reverse Order
for (int i = buffer.Length - 1; i >= 0; i--)
{
if (!subTreeUnpacker.Read())
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
buffer[i] = this._itemSerializer.UnpackFrom(subTreeUnpacker);
}
}
return(Factory(buffer));
}
protected internal override async Task <T> UnpackFromAsyncCore(Unpacker unpacker, CancellationToken cancellationToken)
{
if (!unpacker.IsMapHeader)
{
SerializationExceptions.ThrowIsNotMapHeader(unpacker);
}
var buffer = new KeyValuePair <TKey, TValue> [UnpackHelpers.GetItemsCount(unpacker)];
using (var subTreeUnpacker = unpacker.ReadSubtree())
{
for (int i = 0; i < buffer.Length; i++)
{
if (!await subTreeUnpacker.ReadAsync(cancellationToken).ConfigureAwait(false))
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
var key = await this._keySerializer.UnpackFromAsync(unpacker, cancellationToken).ConfigureAwait(false);
if (!await subTreeUnpacker.ReadAsync(cancellationToken).ConfigureAwait(false))
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
var value = await this._valueSerializer.UnpackFromAsync(unpacker, cancellationToken).ConfigureAwait(false);
buffer[i] = new KeyValuePair <TKey, TValue>(key, value);
}
}
return(this._factory(buffer));
}
protected internal override T UnpackFromCore(Unpacker unpacker)
{
if (!unpacker.IsMapHeader)
{
SerializationExceptions.ThrowIsNotMapHeader(unpacker);
}
var buffer = new KeyValuePair <TKey, TValue> [UnpackHelpers.GetItemsCount(unpacker)];
using (var subTreeUnpacker = unpacker.ReadSubtree())
{
for (int i = 0; i < buffer.Length; i++)
{
if (!subTreeUnpacker.Read())
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
var key = this._keySerializer.UnpackFrom(unpacker);
if (!subTreeUnpacker.Read())
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
var value = this._valueSerializer.UnpackFrom(unpacker);
buffer[i] = new KeyValuePair <TKey, TValue>(key, value);
}
}
return(this._factory(buffer));
}
protected internal override DateTimeOffset UnpackFromCore(Unpacker unpacker)
{
if (unpacker.IsArrayHeader)
{
if (UnpackHelpers.GetItemsCount(unpacker) != 2)
{
SerializationExceptions.ThrowInvalidArrayItemsCount(unpacker, typeof(DateTimeOffset), 2);
}
long ticks;
if (!unpacker.ReadInt64(out ticks))
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
short offsetMinutes;
if (!unpacker.ReadInt16(out offsetMinutes))
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
return(new DateTimeOffset(DateTime.FromBinary(ticks), TimeSpan.FromMinutes(offsetMinutes)));
}
else
{
return(MessagePackConvert.ToDateTimeOffset(unpacker.LastReadData.AsInt64()));
}
}
private static async Task UnpackToAsyncCore(Unpacker unpacker, int count, MessagePackObjectDictionary collection, CancellationToken cancellationToken)
{
for (int i = 0; i < count; i++)
{
if (!await unpacker.ReadAsync(cancellationToken).ConfigureAwait(false))
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
var key = unpacker.LastReadData;
if (!await unpacker.ReadAsync(cancellationToken).ConfigureAwait(false))
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
if (unpacker.IsCollectionHeader)
{
var value = await unpacker.UnpackSubtreeDataAsyncCore(cancellationToken).ConfigureAwait(false);
if (!value.Success)
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
collection.Add(key, value.Value);
}
else
{
collection.Add(key, unpacker.LastReadData);
}
}
}
private static void UnpackToCore(Unpacker unpacker, List <MessagePackObject> collection, int count)
{
for (var i = 0; i < count; i++)
{
if (!unpacker.Read())
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
collection.Add(unpacker.LastReadData);
}
}
private static async Task UnpackToAsyncCore(Unpacker unpacker, List <MessagePackObject> collection, int count, CancellationToken cancellationToken)
{
for (var i = 0; i < count; i++)
{
if (!await unpacker.ReadAsync(cancellationToken).ConfigureAwait(false))
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
collection.Add(unpacker.LastReadData);
}
}
protected internal override async Task <object> UnpackFromAsyncCore(Unpacker unpacker, CancellationToken cancellationToken)
{
if (unpacker.IsArrayHeader)
{
var result = new MessagePackObject[UnpackHelpers.GetItemsCount(unpacker)];
for (int i = 0; i < result.Length; i++)
{
var item = await unpacker.ReadObjectAsync(cancellationToken).ConfigureAwait(false);
if (!item.Success)
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
result[i] = item.Value;
}
return(new MessagePackObject(result));
}
else if (unpacker.IsMapHeader)
{
var itemsCount = UnpackHelpers.GetItemsCount(unpacker);
var result = new MessagePackObjectDictionary(itemsCount);
for (int i = 0; i < itemsCount; i++)
{
var key = await unpacker.ReadObjectAsync(cancellationToken).ConfigureAwait(false);
if (!key.Success)
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
var value = await unpacker.ReadObjectAsync(cancellationToken).ConfigureAwait(false);
if (!value.Success)
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
result.Add(key.Value, value.Value);
}
return(new MessagePackObject(result));
}
else
{
var result = unpacker.LastReadData;
return(result.IsNil ? MessagePackObject.Nil : result);
}
}
protected internal override Complex UnpackFromCore(Unpacker unpacker)
{
double real, imaginary;
if (!unpacker.ReadDouble(out real))
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
if (!unpacker.ReadDouble(out imaginary))
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
return(new Complex(real, imaginary));
}
protected internal override async Task <KeyValuePair <TKey, TValue> > UnpackFromAsyncCore(Unpacker unpacker, CancellationToken cancellationToken)
{
if (!await unpacker.ReadAsync(cancellationToken).ConfigureAwait(false))
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
var key = unpacker.LastReadData.IsNil ? default(TKey) : await this._keySerializer.UnpackFromAsync(unpacker, cancellationToken).ConfigureAwait(false);
if (!await unpacker.ReadAsync(cancellationToken).ConfigureAwait(false))
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
var value = unpacker.LastReadData.IsNil ? default(TValue) : await this._valueSerializer.UnpackFromAsync(unpacker, cancellationToken).ConfigureAwait(false);
return(new KeyValuePair <TKey, TValue>(key, value));
}
protected internal override KeyValuePair <TKey, TValue> UnpackFromCore(Unpacker unpacker)
{
if (!unpacker.Read())
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
var key = unpacker.LastReadData.IsNil ? default(TKey) : this._keySerializer.UnpackFrom(unpacker);
if (!unpacker.Read())
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
var value = unpacker.LastReadData.IsNil ? default(TValue) : this._valueSerializer.UnpackFrom(unpacker);
return(new KeyValuePair <TKey, TValue>(key, value));
}
protected internal override async Task <Complex> UnpackFromAsyncCore(Unpacker unpacker, CancellationToken cancellationToken)
{
var real = await unpacker.ReadDoubleAsync(cancellationToken).ConfigureAwait(false);
if (!real.Success)
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
var imaginary = await unpacker.ReadDoubleAsync(cancellationToken).ConfigureAwait(false);
if (!imaginary.Success)
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
return(new Complex(real.Value, imaginary.Value));
}
protected internal override object UnpackFromCore(Unpacker unpacker)
{
if (unpacker.IsArrayHeader)
{
var result = new MessagePackObject[UnpackHelpers.GetItemsCount(unpacker)];
for (int i = 0; i < result.Length; i++)
{
if (!unpacker.ReadObject(out result[i]))
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
}
return(new MessagePackObject(result));
}
else if (unpacker.IsMapHeader)
{
var itemsCount = UnpackHelpers.GetItemsCount(unpacker);
var result = new MessagePackObjectDictionary(itemsCount);
for (int i = 0; i < itemsCount; i++)
{
MessagePackObject key;
if (!unpacker.ReadObject(out key))
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
MessagePackObject value;
if (!unpacker.ReadObject(out value))
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
result.Add(key, value);
}
return(new MessagePackObject(result));
}
else
{
var result = unpacker.LastReadData;
return(result.IsNil ? MessagePackObject.Nil : result);
}
}
private IEnumerable <TItem> UnpackItemsInReverseOrder(Unpacker unpacker, int count)
{
var buffer = new TItem[count];
using (var subTreeUnpacker = unpacker.ReadSubtree())
{
// Reverse Order
for (var i = buffer.Length - 1; i >= 0; i--)
{
if (!subTreeUnpacker.Read())
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
buffer[i] = this._itemSerializer.UnpackFrom(subTreeUnpacker);
}
}
return(buffer);
}
private async Task <IEnumerable <TItem> > UnpackItemsInReverseOrderAsync(Unpacker unpacker, int count, CancellationToken cancellationToken)
{
var buffer = new TItem[count];
using (var subTreeUnpacker = unpacker.ReadSubtree())
{
// Reverse Order
for (var i = buffer.Length - 1; i >= 0; i--)
{
if (!await subTreeUnpacker.ReadAsync(cancellationToken).ConfigureAwait(false))
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
buffer[i] = await this._itemSerializer.UnpackFromAsync(subTreeUnpacker, cancellationToken).ConfigureAwait(false);
}
}
return(buffer);
}
private static async Task <ICollection> UnpackItemsInReverseOrderAsync(Unpacker unpacker, int count, CancellationToken cancellationToken)
{
var buffer = new object[count];
using (var subTreeUnpacker = unpacker.ReadSubtree())
{
// Reverse Order
for (var i = buffer.Length - 1; i >= 0; i--)
{
if (!await subTreeUnpacker.ReadAsync(cancellationToken).ConfigureAwait(false))
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
buffer[i] = subTreeUnpacker.LastReadData;
}
}
return(buffer);
}
private static ICollection UnpackItemsInReverseOrder(Unpacker unpacker, int count)
{
var buffer = new object[count];
using (var subTreeUnpacker = unpacker.ReadSubtree())
{
// Reverse Order
for (var i = buffer.Length - 1; i >= 0; i--)
{
if (!subTreeUnpacker.Read())
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
buffer[i] = subTreeUnpacker.LastReadData;
}
}
return(buffer);
}
private void UnpackToCore(Unpacker unpacker, Dictionary <TKey, TValue> collection, int count)
{
for (int i = 0; i < count; i++)
{
if (!unpacker.Read())
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
TKey key;
if (unpacker.IsCollectionHeader)
{
using (var subTreeUnpacker = unpacker.ReadSubtree())
{
key = this._keySerializer.UnpackFromCore(subTreeUnpacker);
}
}
else
{
key = this._keySerializer.UnpackFromCore(unpacker);
}
if (!unpacker.Read())
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
if (unpacker.IsCollectionHeader)
{
using (var subTreeUnpacker = unpacker.ReadSubtree())
{
collection.Add(key, this._valueSerializer.UnpackFromCore(subTreeUnpacker));
}
}
else
{
collection.Add(key, this._valueSerializer.UnpackFromCore(unpacker));
}
}
}
private async Task UnpackToAsyncCore(Unpacker unpacker, Dictionary <TKey, TValue> collection, int count, CancellationToken cancellationToken)
{
for (int i = 0; i < count; i++)
{
if (!await unpacker.ReadAsync(cancellationToken).ConfigureAwait(false))
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
TKey key;
if (unpacker.IsCollectionHeader)
{
using (var subTreeUnpacker = unpacker.ReadSubtree())
{
key = await this._keySerializer.UnpackFromAsyncCore(subTreeUnpacker, cancellationToken).ConfigureAwait(false);
}
}
else
{
key = await this._keySerializer.UnpackFromAsyncCore(unpacker, cancellationToken).ConfigureAwait(false);
}
if (!unpacker.Read())
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
if (unpacker.IsCollectionHeader)
{
using (var subTreeUnpacker = unpacker.ReadSubtree())
{
collection.Add(key, await this._valueSerializer.UnpackFromAsyncCore(subTreeUnpacker, cancellationToken).ConfigureAwait(false));
}
}
else
{
collection.Add(key, await this._valueSerializer.UnpackFromAsyncCore(unpacker, cancellationToken).ConfigureAwait(false));
}
}
}
private void ReadArrayMetadata(Unpacker metadataUnpacker, out int[] lengths, out int[] lowerBounds)
{
if (!metadataUnpacker.Read())
{
SerializationExceptions.ThrowUnexpectedEndOfStream(metadataUnpacker);
}
if (!metadataUnpacker.IsArrayHeader)
{
SerializationExceptions.ThrowIsNotArrayHeader(metadataUnpacker);
}
using (var lengthsUnpacker = metadataUnpacker.ReadSubtree())
{
#if !UNITY
lengths = this._int32ArraySerializer.UnpackFrom(lengthsUnpacker);
#else
lengths = this._int32ArraySerializer.UnpackFrom(lengthsUnpacker) as int[];
#endif // !UNITY
}
if (!metadataUnpacker.Read())
{
SerializationExceptions.ThrowUnexpectedEndOfStream(metadataUnpacker);
}
if (!metadataUnpacker.IsArrayHeader)
{
SerializationExceptions.ThrowIsNotArrayHeader(metadataUnpacker);
}
using (var lowerBoundsUnpacker = metadataUnpacker.ReadSubtree())
{
#if !UNITY
lowerBounds = this._int32ArraySerializer.UnpackFrom(lowerBoundsUnpacker);
#else
lowerBounds = this._int32ArraySerializer.UnpackFrom(lowerBoundsUnpacker) as int[];
#endif // !UNITY
}
}
private async Task UnpackToAsyncCore(Unpacker unpacker, List <T> collection, int count, CancellationToken cancellationToken)
{
for (int i = 0; i < count; i++)
{
if (!await unpacker.ReadAsync(cancellationToken).ConfigureAwait(false))
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
if (unpacker.IsCollectionHeader)
{
using (var subTreeUnpacker = unpacker.ReadSubtree())
{
collection.Add(await this._itemSerializer.UnpackFromAsync(subTreeUnpacker, cancellationToken).ConfigureAwait(false));
}
}
else
{
collection.Add(await this._itemSerializer.UnpackFromAsync(unpacker, cancellationToken).ConfigureAwait(false));
}
}
}
private void UnpackToCore(Unpacker unpacker, List <T> collection, int count)
{
for (int i = 0; i < count; i++)
{
if (!unpacker.Read())
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
if (unpacker.IsCollectionHeader)
{
using (var subTreeUnpacker = unpacker.ReadSubtree())
{
collection.Add(this._itemSerializer.UnpackFrom(subTreeUnpacker));
}
}
else
{
collection.Add(this._itemSerializer.UnpackFrom(unpacker));
}
}
}
private static async Task UnpackToAsyncCore(Unpacker unpacker, NameValueCollection collection, int keyCount, CancellationToken cancellationToken)
{
for (var k = 0; k < keyCount; k++)
{
var key = await unpacker.ReadStringAsync(cancellationToken).ConfigureAwait(false);
if (!key.Success)
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
if (!await unpacker.ReadAsync(cancellationToken).ConfigureAwait(false))
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
if (!unpacker.IsArrayHeader)
{
throw new SerializationException("Invalid NameValueCollection value.");
}
var itemsCount = UnpackHelpers.GetItemsCount(unpacker);
using (var valuesUnpacker = unpacker.ReadSubtree())
{
for (var v = 0; v < itemsCount; v++)
{
var value = await valuesUnpacker.ReadStringAsync(cancellationToken).ConfigureAwait(false);
if (!value.Success)
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
collection.Add(key.Value, value.Value);
}
}
}
}
private static void UnpackToCore(Unpacker unpacker, NameValueCollection collection, int keyCount)
{
for (var k = 0; k < keyCount; k++)
{
string key;
if (!unpacker.ReadString(out key))
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
if (!unpacker.Read())
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
if (!unpacker.IsArrayHeader)
{
throw new SerializationException("Invalid NameValueCollection value.");
}
var itemsCount = UnpackHelpers.GetItemsCount(unpacker);
using (var valuesUnpacker = unpacker.ReadSubtree())
{
for (var v = 0; v < itemsCount; v++)
{
string value;
if (!valuesUnpacker.ReadString(out value))
{
SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
}
collection.Add(key, value);
}
}
}
}
private async Task <Tuple <int[], int[]> > ReadArrayMetadataAsync(Unpacker metadataUnpacker, CancellationToken cancellationToken)
{
if (!await metadataUnpacker.ReadAsync(cancellationToken).ConfigureAwait(false))
{
SerializationExceptions.ThrowUnexpectedEndOfStream(metadataUnpacker);
}
if (!metadataUnpacker.IsArrayHeader)
{
SerializationExceptions.ThrowIsNotArrayHeader(metadataUnpacker);
}
int[] lengths, lowerBounds;
using (var lengthsUnpacker = metadataUnpacker.ReadSubtree())
{
lengths = await this._int32ArraySerializer.UnpackFromAsync(lengthsUnpacker, cancellationToken).ConfigureAwait(false);
}
if (!await metadataUnpacker.ReadAsync(cancellationToken).ConfigureAwait(false))
{
SerializationExceptions.ThrowUnexpectedEndOfStream(metadataUnpacker);
}
if (!metadataUnpacker.IsArrayHeader)
{
SerializationExceptions.ThrowIsNotArrayHeader(metadataUnpacker);
}
using (var lowerBoundsUnpacker = metadataUnpacker.ReadSubtree())
{
lowerBounds = await this._int32ArraySerializer.UnpackFromAsync(lowerBoundsUnpacker, cancellationToken).ConfigureAwait(false);
}
return(Tuple.Create(lengths, lowerBounds));
}
