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