ProgressIncrementingStream
Wraps a stream, and reports position updates to a progress incrementer
using System.IO;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;
namespace Azure.Storage
{
internal class ProgressIncrementingStream : Stream
{
private readonly Stream _innerStream;
private readonly AggregatingProgressIncrementer _incrementer;
public override bool CanRead => _innerStream.CanRead;
public override bool CanSeek => _innerStream.CanSeek;
public override bool CanTimeout => _innerStream.CanTimeout;
public override bool CanWrite => _innerStream.CanWrite;
public override long Length => _innerStream.Length;
public override long Position {
get {
return _innerStream.Position;
}
set {
long bytes = value - _innerStream.Position;
_innerStream.Position = value;
_incrementer.Report(bytes);
}
}
public override int ReadTimeout {
get {
return _innerStream.ReadTimeout;
}
set {
_innerStream.ReadTimeout = value;
}
}
public override int WriteTimeout {
get {
return _innerStream.WriteTimeout;
}
set {
_innerStream.WriteTimeout = value;
}
}
public ProgressIncrementingStream(Stream stream, AggregatingProgressIncrementer incrementer)
{
if (stream == null)
throw Errors.ArgumentNull("stream");
_innerStream = stream;
if (incrementer == null)
throw Errors.ArgumentNull("incrementer");
_incrementer = incrementer;
}
protected override void Dispose(bool disposing)
{
base.Dispose(disposing);
_innerStream.Dispose();
}
[AsyncStateMachine(typeof(<FlushAsync>d__12))]
public override Task FlushAsync(CancellationToken cancellationToken)
{
<FlushAsync>d__12 stateMachine = default(<FlushAsync>d__12);
stateMachine.<>t__builder = AsyncTaskMethodBuilder.Create();
stateMachine.<>4__this = this;
stateMachine.cancellationToken = cancellationToken;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start(ref stateMachine);
return stateMachine.<>t__builder.Task;
}
public override void Flush()
{
long position = _innerStream.Position;
_innerStream.Flush();
long position2 = _innerStream.Position;
_incrementer.Report(position2 - position);
}
public override int Read(byte[] buffer, int offset, int count)
{
int num = _innerStream.Read(buffer, offset, count);
_incrementer.Report(num);
return num;
}
[AsyncStateMachine(typeof(<ReadAsync>d__20))]
public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
{
<ReadAsync>d__20 stateMachine = default(<ReadAsync>d__20);
stateMachine.<>t__builder = AsyncTaskMethodBuilder<int>.Create();
stateMachine.<>4__this = this;
stateMachine.buffer = buffer;
stateMachine.offset = offset;
stateMachine.count = count;
stateMachine.cancellationToken = cancellationToken;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start(ref stateMachine);
return stateMachine.<>t__builder.Task;
}
public override int ReadByte()
{
int num = _innerStream.ReadByte();
if (num != -1)
_incrementer.Report(1);
return num;
}
public override long Seek(long offset, SeekOrigin origin)
{
long position = _innerStream.Position;
long num = _innerStream.Seek(offset, origin);
_incrementer.Report(num - position);
return num;
}
public override void SetLength(long value)
{
_innerStream.SetLength(value);
}
public override void Write(byte[] buffer, int offset, int count)
{
_innerStream.Write(buffer, offset, count);
_incrementer.Report(count);
}
[AsyncStateMachine(typeof(<WriteAsync>d__28))]
public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
{
<WriteAsync>d__28 stateMachine = default(<WriteAsync>d__28);
stateMachine.<>t__builder = AsyncTaskMethodBuilder.Create();
stateMachine.<>4__this = this;
stateMachine.buffer = buffer;
stateMachine.offset = offset;
stateMachine.count = count;
stateMachine.cancellationToken = cancellationToken;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start(ref stateMachine);
return stateMachine.<>t__builder.Task;
}
public override void WriteByte(byte value)
{
_innerStream.WriteByte(value);
_incrementer.Report(1);
}
}
}