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)); }