private Task <AsyncReadResult <Int32OffsetValue <byte[]> > > ReadBinaryCoreAsync(int length, int offset, CancellationToken cancellationToken)
{
byte[] result;
if (!this.ReadBinaryCore(length, ref offset, out result))
{
return(Task.FromResult(AsyncReadResult.Fail <Int32OffsetValue <byte[]> >()));
}
return(Task.FromResult(AsyncReadResult.Success(result, offset)));
}
private async Task <AsyncReadResult <Int64OffsetValue <string> > > ReadStringCoreAsync(int length, long offset, CancellationToken cancellationToken)
{
this._lastOffset = this._offset;
if (length == 0)
{
return(AsyncReadResult.Success(String.Empty, offset));
}
// TODO: Span<byte>
var byteBuffer = BufferManager.NewByteBuffer(length * 4);
var charBuffer = BufferManager.NewCharBuffer(length);
var resultBuffer = new StringBuilder(length);
var decoder = MessagePackConvert.Utf8NonBomStrict.GetDecoder();
var remaining = length;
#if DEBUG
bool isCompleted;
#endif // DEBUG
// Retrying for splitted Stream such as NetworkStream
do
{
var reading = Math.Min(byteBuffer.Length, remaining);
var readLength = await this._source.ReadAsync(byteBuffer, 0, reading, cancellationToken).ConfigureAwait(false);
if (readLength == 0)
{
if (this._useStreamPosition)
{
// Rollback
this._source.Position -= resultBuffer.Length;
}
else
{
// Throw because rollback is not available
this.ThrowEofException(reading);
}
return(AsyncReadResult.Fail <Int64OffsetValue <string> >());
}
#if DEBUG
isCompleted =
#endif // DEBUG
decoder.DecodeString(byteBuffer, 0, readLength, charBuffer, resultBuffer);
remaining -= readLength;
} while (remaining > 0);
#if DEBUG
Contract.Assert(isCompleted, "isCompleted == true");
#endif // DEBUG
offset += length;
return(AsyncReadResult.Success(resultBuffer.ToString(), offset));
}
private Task <AsyncReadResult <Int32OffsetValue <MessagePackString> > > ReadRawStringCoreAsync(int length, int offset, CancellationToken cancellationToken)
{
MessagePackString result;
if (!this.ReadRawStringCore(length, ref offset, out result))
{
return(Task.FromResult(AsyncReadResult.Fail <Int32OffsetValue <MessagePackString> >()));
}
return(Task.FromResult(AsyncReadResult.Success(result, offset)));
}
private async Task <AsyncReadResult <Int64OffsetValue <byte[]> > > ReadBinaryCoreAsync(int length, long offset, CancellationToken cancellationToken)
{
this._lastOffset = this._offset;
if (length == 0)
{
return(AsyncReadResult.Success(Binary.Empty, offset));
}
var result = new byte[length];
var bufferOffset = 0;
var reading = length;
// Retrying for splitted Stream such as NetworkStream
while (true)
{
var readLength = await this._source.ReadAsync(result, bufferOffset, reading, cancellationToken).ConfigureAwait(false);
if (readLength < reading)
{
if (readLength > 0)
{
// retry reading
bufferOffset += readLength;
reading -= readLength;
continue;
}
else
{
if (this._useStreamPosition)
{
// Rollback
this._source.Position -= (bufferOffset + readLength);
}
else
{
// Throw because rollback is not available
this.ThrowEofException(reading);
}
}
return(AsyncReadResult.Fail <Int64OffsetValue <byte[]> >());
}
break;
}
offset += length;
return(AsyncReadResult.Success(result, offset));
}
internal async Task <AsyncReadResult <MessagePackObject> > UnpackSubtreeDataAsyncCore(CancellationToken cancellationToken)
{
if (this.IsArrayHeader)
{
var array = new MessagePackObject[checked (( int )this.LastReadData.AsUInt32())];
using (var subTreeReader = this.ReadSubtree())
{
for (int i = 0; i < array.Length; i++)
{
array[i] = await subTreeReader.ReadItemDataAsync(cancellationToken).ConfigureAwait(false);
}
}
return(AsyncReadResult.Success(new MessagePackObject(array, true)));
}
else if (this.IsMapHeader)
{
var capacity = checked (( int )this.LastReadData.AsUInt32());
var map = new MessagePackObjectDictionary(capacity);
using (var subTreeReader = this.ReadSubtree())
{
for (int i = 0; i < capacity; i++)
{
var key = await subTreeReader.ReadItemDataAsync(cancellationToken).ConfigureAwait(false);
var value = await subTreeReader.ReadItemDataAsync(cancellationToken).ConfigureAwait(false);
map.Add(key, value);
}
}
return(AsyncReadResult.Success(new MessagePackObject(map, true)));
}
else
{
return(AsyncReadResult.Fail <MessagePackObject>());
}
}
private async Task <AsyncReadResult <Int64OffsetValue <MessagePackString> > > ReadRawStringCoreAsync(int length, long offset, CancellationToken cancellationToken)
{
var asyncReadResult = await this.ReadBinaryCoreAsync(length, offset, cancellationToken).ConfigureAwait(false);
if (!asyncReadResult.Success)
{
return(AsyncReadResult.Fail <Int64OffsetValue <MessagePackString> >());
}
var asBinary = asyncReadResult.Value.Result;
MessagePackString result;
try
{
result = new MessagePackString(MessagePackConvert.Utf8NonBomStrict.GetString(asBinary, 0, asBinary.Length));
}
catch (DecoderFallbackException)
{
result = new MessagePackString(asBinary, true);
}
return(AsyncReadResult.Success(result, asyncReadResult.Value.Offset));
}
/// <summary>
/// Determines whether the current object is equal to another object of the same type.
/// </summary>
/// <param name="other">An object to compare with this object.</param>
/// <returns>
/// <c>true</c> if the current object is equal to the <paramref name="other" /> parameter; otherwise, <c>false</c>.
/// </returns>
public bool Equals(AsyncReadResult <T> other)
{
return(this._success == other._success && EqualityComparer <T> .Default.Equals(this._value, other._value));
}
