public IPipelineWriter CreateWriter(Stream stream)
{
if (!stream.CanWrite)
{
ThrowHelper.ThrowNotSupportedException();
}
var input = new PipelineReaderWriter(_pool);
input.CopyToAsync(stream).ContinueWith((task, state) =>
{
var innerInput = (PipelineReaderWriter)state;
if (task.IsFaulted)
{
innerInput.CompleteReader(task.Exception.InnerException);
}
else
{
innerInput.CompleteReader();
}
},
input, CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
return(input);
}
public IPipelineReader CreateReader(IPipelineReader reader, Func <IPipelineReader, IPipelineWriter, Task> produce)
{
var newReader = new PipelineReaderWriter(_pool);
Execute(reader, newReader, produce);
return(newReader);
}
public IPipelineWriter CreateWriter(Stream stream)
{
if (!stream.CanWrite)
{
ThrowHelper.ThrowNotSupportedException();
}
var input = new PipelineReaderWriter(_pool);
input.CopyToAsync(stream).ContinueWith((task, state) =>
{
var innerInput = (PipelineReaderWriter)state;
if (task.IsFaulted)
{
innerInput.CompleteReader(task.Exception.InnerException);
}
else
{
innerInput.CompleteReader();
}
},
input, CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
return input;
}
public IPipelineWriter CreateWriter(IPipelineWriter writer, Func <IPipelineReader, IPipelineWriter, Task> consume)
{
var newWriter = new PipelineReaderWriter(_pool);
consume(newWriter, writer).ContinueWith(t =>
{
});
return(newWriter);
}
public IPipelineWriter CreateWriter(IPipelineWriter writer, Func<IPipelineReader, IPipelineWriter, Task> consume)
{
var newWriter = new PipelineReaderWriter(_pool);
consume(newWriter, writer).ContinueWith(t =>
{
});
return newWriter;
}
public IPipelineReader CreateReader(Stream stream)
{
if (!stream.CanRead)
{
ThrowHelper.ThrowNotSupportedException();
}
var output = new PipelineReaderWriter(_pool);
ExecuteCopyToAsync(output, stream);
return output;
}
public IPipelineReader CreateReader(Stream stream)
{
if (!stream.CanRead)
{
ThrowHelper.ThrowNotSupportedException();
}
var output = new PipelineReaderWriter(_pool);
ExecuteCopyToAsync(output, stream);
return(output);
}
/// <summary>
/// Adapts a <see cref="Stream"/> into a <see cref="IPipelineWriter"/>.
/// </summary>
/// <param name="stream"></param>
/// <param name="pool"></param>
/// <returns></returns>
public static IPipelineWriter AsPipelineWriter(this Stream stream, IBufferPool pool)
{
var writer = new PipelineReaderWriter(pool);
writer.CopyToAsync(stream).ContinueWith((task, state) =>
{
var innerWriter = (PipelineReaderWriter)state;
if (task.IsFaulted)
{
innerWriter.CompleteReader(task.Exception.InnerException);
}
else
{
innerWriter.CompleteReader();
}
},
writer, CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
return writer;
}
/// <summary>
/// Adapts a <see cref="Stream"/> into a <see cref="IPipelineWriter"/>.
/// </summary>
/// <param name="stream"></param>
/// <param name="pool"></param>
/// <returns></returns>
public static IPipelineWriter AsPipelineWriter(this Stream stream, IBufferPool pool)
{
var writer = new PipelineReaderWriter(pool);
writer.CopyToAsync(stream).ContinueWith((task, state) =>
{
var innerWriter = (PipelineReaderWriter)state;
if (task.IsFaulted)
{
innerWriter.CompleteReader(task.Exception.InnerException);
}
else
{
innerWriter.CompleteReader();
}
},
writer, CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
return(writer);
}
private async void ExecuteCopyToAsync(PipelineReaderWriter output, Stream stream)
{
await output.ReadingStarted;
await stream.CopyToAsync(output);
}
internal WritableBuffer(PipelineReaderWriter output)
{
_output = output;
}
private async void Execute(IPipelineReader reader, PipelineReaderWriter writer, Func <IPipelineReader, IPipelineWriter, Task> produce)
{
await writer.ReadingStarted;
await produce(reader, writer);
}
public IPipelineReader CreateReader(IPipelineReader reader, Func<IPipelineReader, IPipelineWriter, Task> produce)
{
var newReader = new PipelineReaderWriter(_pool);
Execute(reader, newReader, produce);
return newReader;
}
/// <summary>
/// Creates a base <see cref="PipelineReader"/>.
/// </summary>
/// <param name="pool">The <see cref="IBufferPool"/> that buffers will be allocated from.</param>
protected PipelineReader(IBufferPool pool)
{
_input = new PipelineReaderWriter(pool);
}
public PipelineWriter(IBufferPool pool)
{
_output = new PipelineReaderWriter(pool);
Consume(_output);
}
private async void ExecuteCopyToAsync(PipelineReaderWriter output, Stream stream)
{
await output.ReadingStarted;
await stream.CopyToAsync(output);
}
/// <summary>
/// Creates a base <see cref="PipelineReader"/>.
/// </summary>
/// <param name="input">The <see cref="PipelineReaderWriter"/> the <see cref="PipelineReader"/> communicates over.</param>
protected PipelineReader(PipelineReaderWriter input)
{
_input = input;
}
public PipelineWriter(IBufferPool pool)
{
_output = new PipelineReaderWriter(pool);
Consume(_output);
}
private async void Execute(IPipelineReader reader, PipelineReaderWriter writer, Func<IPipelineReader, IPipelineWriter, Task> produce)
{
await writer.ReadingStarted;
await produce(reader, writer);
}
internal WritableBuffer(PipelineReaderWriter output)
{
_output = output;
}
