Make LineSplitter.split return an Iterable<String>, not Iterable<>.

sdk/lib/convert/line_splitter.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.convert;
 
 // Character constants.
 const int _LF = 10;
 const int _CR = 13;
 
 /**
  * A [Converter] that splits a [String] into individual lines.
  *
  * A line is terminated by either a CR (U+000D), a LF (U+000A), a
  * CR+LF sequence (DOS line ending),
  * and a final non-empty line can be ended by the end of the string.
  *
  * The returned lines do not contain the line terminators.
  */
 class LineSplitter extends Converter<String, List<String>> {
 
   const LineSplitter();
 
   /// Split [lines] into individual lines.
   ///
   /// If [start] and [end] are provided, only split the contents of
   /// `lines.substring(start, end)`. The [start] and [end] values must
   /// specify a valid sub-range of [lines]
   /// (`0 <= start <= end <= lines.length`).
-  static Iterable<String> split(String lines, [int start = 0, int end]) sync* {
+  static Iterable<String> split(String lines, [int start = 0, int end]) {
     end = RangeError.checkValidRange(start, end, lines.length);
-    int sliceStart = start;
-    int char = 0;
-    for (int i = start; i < end; i++) {
-      int previousChar = char;
-      char = lines.codeUnitAt(i);
-      if (char != _CR) {
-        if (char != _LF) continue;
-        if (previousChar == _CR) {
-          sliceStart = i + 1;
-          continue;
-        }
-      }
-      yield lines.substring(sliceStart, i);
-      sliceStart = i + 1;
-    }
-    if (sliceStart < end) {
-      yield lines.substring(sliceStart, end);
-    }
+    return new _LineIterable(lines, start, end);
   }
 
   List<String> convert(String data) => split(data).toList();
 
   StringConversionSink startChunkedConversion(Sink<String> sink) {
     if (sink is! StringConversionSink) {
       sink = new StringConversionSink.from(sink);
     }
     return new _LineSplitterSink(sink);
   }
 }
 
+class _LineIterable extends Iterable<String> {
+  final String _string;
+  final int _start;
+  final int _end;
+  _LineIterable(this._string, this._start, this._end);
+  Iterator<String> get iterator => new _LineIterator(_string, _start, _end);
+
+  bool get isEmpty => _start < _end;
+  bool get isNotEmpty => _start >= end;
+}
+
+class _LineIterator implements Iterator<String> {
+  final String _string;
+  final int _end;
+  int _index;
+  String _current;
+  _LineIterator(this._string, this._index, this._end);
+
+  String get current => _current;
+
+  bool moveNext() {
+    if (_index < _end) {
+      int terminatorLength = 1;
+      int i = _index;
+      findEnd: {
+        while (i < _end) {
+          int char = _string.codeUnitAt(i++);
+          if (char != _LF) {
+            if (char != _CR) continue;
+            // Break on CR or CR+LF

[floitsch, 2016/03/08 12:35:34]

Finish with "."

+            if (i < _end && _string.codeUnitAt(i) == _LF) {
+              terminatorLength = 2;
+              i++;
+            }
+          }
+          break findEnd;
+        }
+        terminatorLength = 0;  // Terminated by the end, not a char.
+      }
+      _current = _string.substring(_index, i - terminatorLength);
+      _index = i;
+      return true;
+    }
+    _current = null;
+    return false;
+  }
+}
+
 // TODO(floitsch): deal with utf8.
 class _LineSplitterSink extends StringConversionSinkBase {
   final StringConversionSink _sink;
 
   /// The carry-over from the previous chunk.
   ///
   /// If the previous slice ended in a line without a line terminator,
   /// then the next slice may continue the line.
   String _carry;
 
@@ skipping 55 matching lines @@
       _sink.add(lines.substring(sliceStart, i));
       sliceStart = i + 1;
     }
     if (sliceStart < end) {
       _carry = lines.substring(sliceStart, end);
     } else {
       _skipLeadingLF = (char == _CR);
     }
   }
 }