Update ZLib/GZip in dart:io to be a Codec/Converter from dart:convert.

sdk/lib/io/data_transformer.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of dart.io;
 
+
+const ZLIB = const ZLibCodec();

[floitsch, 2013/08/22 15:04:05]

add comments.

[Søren Gjesse, 2013/08/22 15:10:37]

Documentation for the ZLIB object?

[Anders Johnsen, 2013/08/22 15:58:01]

Done.

[Anders Johnsen, 2013/08/22 15:58:01]

Done.

+
+
+class ZLibCodec extends Codec<List<int>, List<int>> {

[floitsch, 2013/08/22 15:04:05]

add comments and for all other classes / methods.

Don't forget to explain the difference between ZLIB and GZIP.

[Søren Gjesse, 2013/08/22 15:10:37]

And for the codec.

[Anders Johnsen, 2013/08/22 15:58:01]

Done.

[Anders Johnsen, 2013/08/22 15:58:01]

Done.

+  final Converter<List<int>, List<int>> encoder =
+      const ZLibEncoder(gzip: false);
+  final Converter<List<int>, List<int>> decoder = const ZLibDecoder();
+
+  const ZLibCodec();
+}
+
+
+const GZIP = const GZipCodec();

[Søren Gjesse, 2013/08/22 15:10:37]

Ditto.

[Anders Johnsen, 2013/08/22 15:58:01]

Done.

+
+
+class GZipCodec extends Codec<List<int>, List<int>> {

[Søren Gjesse, 2013/08/22 15:10:37]

Ditto.

[Anders Johnsen, 2013/08/22 15:58:01]

Done.

+  final Converter<List<int>, List<int>> encoder = const ZLibEncoder(gzip: true);
+  final Converter<List<int>, List<int>> decoder = const ZLibDecoder();
+
+  const GZipCodec();
+}
+
+
+class ZLibEncoder extends Converter<List<int>, List<int>> {

[floitsch, 2013/08/22 15:04:05]

Still misses the synchronous convert function.
You can just use the startChunkedConversion to do it.

Add some synchronous tests.

[Anders Johnsen, 2013/08/22 15:58:01]

Done.

+  final bool gzip;
+  final int level;
+
+  /**
+   * Create a new [ZLibEncoder] converter. If the [gzip] flag is set, the
+   * encoder will wrap the encoded ZLib data in GZip frames.
+   */
+  const ZLibEncoder({this.gzip: false, this.level: 6});
+
+  ByteConversionSink startChunkedConversion(

[floitsch, 2013/08/22 15:04:05]

Comment explaining that the function is more efficient with a
ByteConversionSink.

ditto for other.

[Anders Johnsen, 2013/08/22 15:58:01]

Done.

+      ChunkedConversionSink<List<int>> sink) {
+    if (sink is! ByteConversionSink) {
+      sink = new ByteConversionSink.from(sink);
+    }
+    return new _ZLibEncoderSink(sink, gzip, level);
+  }
+}
+
+
+class ZLibDecoder extends Converter<List<int>, List<int>> {

[Søren Gjesse, 2013/08/22 15:10:37]

Add comment for this constructor as well. Currently dartdoc will put in the doc
from the super constructor is there is no doc, which is pretty confusing.

[Anders Johnsen, 2013/08/22 15:58:01]

Done.

+  const ZLibDecoder();
+
+  ByteConversionSink startChunkedConversion(
+      ChunkedConversionSink<List<int>> sink) {
+    if (sink is! ByteConversionSink) {
+      sink = new ByteConversionSink.from(sink);
+    }
+    return new _ZLibDecoderSink(sink);
+  }
+}
+
+
+class _ZLibEncoderSink extends _FilterSink {
+  _ZLibEncoderSink(ByteConversionSink sink, bool gzip, int level)
+      : super(sink, _Filter.newZLibDeflateFilter(gzip, level));
+}
+
+
+class _ZLibDecoderSink extends _FilterSink {
+  _ZLibDecoderSink(ByteConversionSink sink)
+      : super(sink, _Filter.newZLibInflateFilter());
+}
+
+
+class _FilterSink extends ByteConversionSink {
+  final _Filter _filter;
+  final ByteConversionSink _sink;
+  bool _closed = false;
+  bool _empty = true;
+
+  _FilterSink(ByteConversionSink this._sink, _Filter this._filter);
+
+  void add(List<int> data) {
+    addSlice(data, 0, data.length, false);
+  }
+
+  void addSlice(List<int> data, int start, int end, bool isLast) {
+    if (_closed) return;
+    if (start < 0 || start > data.length) {
+      throw ArgumentError("Invalid start position");
+    }
+    if (end < 0 || end > data.length || end < start) {
+      throw ArgumentError("Invalid end position");
+    }
+    try {
+      _empty = false;
+      _filter.process(data, start, end);
+      var out;
+      while ((out = _filter.processed(flush: false)) != null) {
+        _sink.add(out);
+      }
+    } catch (e) {
+      _closed = true;
+      throw e;
+    }
+
+    if (isLast) close();
+  }
+
+  void close() {
+    if (_closed) return;
+    if (_empty) _filter.process(const [], 0, 0);

[floitsch, 2013/08/22 15:04:05]

can't you replace this and the following lines with: addSlice([], 0, 0, false)

Add comment that you need to call _filter.process at least once (at least that's
what I understand).

[Anders Johnsen, 2013/08/22 15:58:01]

Added comment. And no, since we don't want to write [] unless we really mean it
(otherwise we might get an extra frame).

+    try {
+      var out;
+      while ((out = _filter.processed(end: true)) != null) {
+        _sink.add(out);
+      }
+    } catch (e) {
+      _closed = true;
+      throw e;
+    }
+    if (!_closed) _filter.end();
+    _closed = true;
+    _sink.close();
+  }
+}
+
+
+
 /**
  * Private helper-class to handle native filters.
  */
 abstract class _Filter {
   /**
    * Call to process a chunk of data. A call to [process] should only be made
    * when [processed] returns [null].
    */
-  void process(List<int> data);
+  void process(List<int> data, int start, int end);
 
   /**
    * Get a chunk of processed data. When there are no more data available,
    * [processed] will return [null]. Set [flush] to [false] for non-final
    * calls to improve performance of some filters.
    *
    * The last call to [processed] should have [end] set to [true]. This will make
    * sure a 'end' packet is written on the stream.
    */
   List<int> processed({bool flush: true, bool end: false});
 
   /**
    * Mark the filter as closed. Always call this method for any filter created
    * to avoid leaking resources. [end] can be called at any time, but any
    * successive calls to [process] or [processed] will fail.
    */
   void end();
 
   external static _Filter newZLibDeflateFilter(bool gzip, int level);
   external static _Filter newZLibInflateFilter();
 }
-
-
-class _FilterTransformer extends StreamEventTransformer<List<int>, List<int>> {
-  final _Filter _filter;
-  bool _closed = false;
-  bool _empty = true;
-
-  _FilterTransformer(_Filter this._filter);
-
-  void handleData(List<int> data, EventSink<List<int>> sink) {
-    if (_closed) return;
-    try {
-      _empty = false;
-      _filter.process(data);
-      var out;
-      while ((out = _filter.processed(flush: false)) != null) {
-        sink.add(out);
-      }
-    } catch (e, s) {
-      _closed = true;
-      // TODO(floitsch): we are losing the stack trace.
-      sink.addError(e);
-      sink.close();
-    }
-  }
-
-  void handleDone(EventSink<List<int>> sink) {
-    if (_closed) return;
-    if (_empty) _filter.process(const []);
-    try {
-      var out;
-      while ((out = _filter.processed(end: true)) != null) {
-        sink.add(out);
-      }
-    } catch (e, s) {
-      // TODO(floitsch): we are losing the stack trace.
-      sink.addError(e);
-      _closed = true;
-    }
-    if (!_closed) _filter.end();
-    _closed = true;
-    sink.close();
-  }
-}
-
-
-/**
- * ZLibDeflater class used to deflate a stream of bytes, using zlib.
- */
-class ZLibDeflater extends _FilterTransformer {
-  ZLibDeflater({bool gzip: true, int level: 6})
-      : super(_Filter.newZLibDeflateFilter(gzip, level));
-}
-
-
-/**
- * ZLibInflater class used to inflate a stream of bytes, using zlib.
- */
-class ZLibInflater extends _FilterTransformer {
-  ZLibInflater() : super(_Filter.newZLibInflateFilter());
-}
-