private void IntermediateWrite(IAsyncResult asyncResult)
{
ZlibState state = (ZlibState)asyncResult.AsyncState;
try
{
m_stream.EndWrite(asyncResult);
}
catch (Exception e)
{
ZlibStreamAsyncResult res = new ZlibStreamAsyncResult(state.state, e);
state.callback(res);
return;
}
m_out.next_out_index = 0;
m_out.avail_out = bufsize;
int err = m_out.deflate(m_flush);
if (err != zlibConst.Z_STREAM_END)
{
if (err != zlibConst.Z_OK)
{
ZlibStreamAsyncResult res = new ZlibStreamAsyncResult(state.state, new CompressionFailedException("Compress failed: " + err));
state.callback(res);
return;
}
}
if (m_out.avail_in == 0)
{
m_stream.BeginWrite(m_outbuf, 0, bufsize - m_out.avail_out, state.callback, state.state);
}
else
{
m_stream.BeginWrite(m_outbuf, 0, bufsize - m_out.avail_out, new AsyncCallback(IntermediateWrite), state);
}
}
private void IntermediateWrite(IAsyncResult asyncResult)
{
ZlibState state = (ZlibState)asyncResult.AsyncState;
try
{
m_stream.EndWrite(asyncResult);
}
catch (Exception e)
{
ZlibStreamAsyncResult res = new ZlibStreamAsyncResult(state.state, e);
state.callback(res);
return;
}
m_out.next_out_index = 0;
m_out.avail_out = bufsize;
int err = m_out.deflate(m_flush);
if (err != zlibConst.Z_STREAM_END)
{
if (err != zlibConst.Z_OK)
{
ZlibStreamAsyncResult res = new ZlibStreamAsyncResult(state.state, new CompressionFailedException("Compress failed: " + err));
state.callback(res);
return;
}
}
if (m_out.avail_in == 0)
m_stream.BeginWrite(m_outbuf, 0, bufsize - m_out.avail_out, state.callback, state.state);
else
m_stream.BeginWrite(m_outbuf, 0, bufsize - m_out.avail_out, new AsyncCallback(IntermediateWrite), state);
}
/// <summary>
/// Begin an asynch write, compressing first. Implemented locally, since Stream.BeginWrite isn't asynch.
/// Note: may call Write() on the underlying stream more than once.
/// </summary>
/// <param name="buffer"></param>
/// <param name="offset"></param>
/// <param name="count"></param>
/// <param name="callback"></param>
/// <param name="state"></param>
/// <returns></returns>
public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
if (count <= 0)
throw new ArgumentException("Can't write 0 bytes", "count");
m_out.next_in = buffer;
m_out.next_in_index = offset;
m_out.avail_in = count;
m_out.next_out_index = 0;
m_out.avail_out = bufsize;
int err = m_out.deflate(m_flush);
if (err != zlibConst.Z_STREAM_END)
{
if (err != zlibConst.Z_OK)
{
ZlibStreamAsyncResult res = new ZlibStreamAsyncResult(state, new CompressionFailedException("Compress failed: " + err));
callback(res);
return res;
}
}
if (m_out.avail_in == 0)
return m_stream.BeginWrite(m_outbuf, 0, bufsize - m_out.avail_out, callback, state);
else
return m_stream.BeginWrite(m_outbuf, 0, bufsize - m_out.avail_out, new AsyncCallback(IntermediateWrite), new ZlibState(callback, state));
}
/// <summary>
/// Start an async read. Implemented locally, since Stream.BeginRead() isn't really asynch.
/// </summary>
/// <param name="buffer"></param>
/// <param name="offset"></param>
/// <param name="count"></param>
/// <param name="callback"></param>
/// <param name="state"></param>
/// <returns></returns>
public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
if (count <= 0)
throw new ArgumentException("Can't read 0 bytes", "count");
m_in.next_out = buffer;
m_in.next_out_index = offset;
m_in.avail_out = count;
if (m_in.avail_in == 0)
{
m_in.next_in_index = 0;
return m_stream.BeginRead(m_inbuf, 0, bufsize, callback, state);
}
ZlibStreamAsyncResult ar = new ZlibStreamAsyncResult(state);
callback(ar);
return ar;
}
public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback cback, object state)
{
if (count <= 0)
throw new ArgumentException("Cannot read 0 bytes", "count");
_in.next_out = buffer;
_in.next_out_index = offset;
_in.avail_out = count;
if (_in.avail_in == 0)
{
_in.next_in_index = 0;
return _innerStream.BeginRead(_inBuff, 0, _buffSize, cback, state);
}
ZlibStreamAsyncResult ar = new ZlibStreamAsyncResult(state);
cback(ar);
return ar;
}
public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback cback, object state)
{
_outBuff = buffer;
if ( _in.IsNeedingInput )
return _innerStream.BeginRead(_inBuff, 0, _inBuff.Length, cback, state);
ZlibStreamAsyncResult ar = new ZlibStreamAsyncResult(state);
cback(ar);
return ar;
}
public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, System.AsyncCallback callback, object state)
{
if (count <= 0)
throw new ArgumentOutOfRangeException("count", "Can't read zero or less bytes");
_in.OutputBuffer = buffer;
_in.NextOut = offset;
_in.AvailableBytesOut = count;
if (_in.AvailableBytesIn == 0)
{
_in.NextIn = 0;
return _inner.BeginRead(_inBuff, 0, _bufferSize, callback, state);
}
ZlibStreamAsyncResult ar = new ZlibStreamAsyncResult(state);
callback(ar);
return ar;
}
