Use iterator, moveNext(), current.

sdk/lib/utf/utf16.dart

 // Copyright (c) 2012, 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.
 
 
 /**
  * Decodes the UTF-16 bytes as an iterable. Thus, the consumer can only convert
  * as much of the input as needed. Determines the byte order from the BOM,
  * or uses big-endian as a default. This method always strips a leading BOM.
  * Set the [replacementCodepoint] to null to throw an ArgumentError
@@ skipping 203 matching lines @@
  * Return type of [decodeUtf16AsIterable] and variants. The Iterable type
  * provides an iterator on demand and the iterator will only translate bytes
  * as requested by the user of the iterator. (Note: results are not cached.)
  */
 class IterableUtf16Decoder extends Iterable<int> {
   final _CodeUnitsProvider codeunitsProvider;
   final int replacementCodepoint;
 
   IterableUtf16Decoder._(this.codeunitsProvider, this.replacementCodepoint);
 
-  Utf16CodeUnitDecoder iterator() =>
+  Utf16CodeUnitDecoder get iterator =>
       new Utf16CodeUnitDecoder.fromListRangeIterator(codeunitsProvider(),
           replacementCodepoint);
 }
 
 /**
  * Convert UTF-16 encoded bytes to UTF-16 code units by grouping 1-2 bytes
  * to produce the code unit (0-(2^16)-1). Relies on BOM to determine
  * endian-ness, and defaults to BE.
  */
 class Utf16BytesToCodeUnitsDecoder implements _ListRangeIterator {
   final _ListRangeIterator utf16EncodedBytesIterator;
   final int replacementCodepoint;
+  int _current = -1;
 
   Utf16BytesToCodeUnitsDecoder._fromListRangeIterator(
       this.utf16EncodedBytesIterator, this.replacementCodepoint);
 
   factory Utf16BytesToCodeUnitsDecoder(List<int> utf16EncodedBytes, [
       int offset = 0, int length,
       int replacementCodepoint = UNICODE_REPLACEMENT_CHARACTER_CODEPOINT]) {
     if (length == null) {
       length = utf16EncodedBytes.length - offset;
     }
@@ skipping 10 matching lines @@
   }
 
   /**
    * Provides a fast way to decode the rest of the source bytes in a single
    * call. This method trades memory for improved speed in that it potentially
    * over-allocates the List containing results.
    */
   List<int> decodeRest() {
     List<int> codeunits = new List<int>(remaining);
     int i = 0;
-    while (hasNext) {
-      codeunits[i++] = next();
+    while (moveNext()) {
+      codeunits[i++] = current;
     }
     if (i == codeunits.length) {
       return codeunits;
     } else {
       List<int> truncCodeunits = new List<int>(i);
       truncCodeunits.setRange(0, i, codeunits);
       return truncCodeunits;
     }
   }
 
-  bool get hasNext => utf16EncodedBytesIterator.hasNext;
+  int get current {
+    if (_current == -1) {
+      // TODO(floitsch): bad error message.
+      throw new StateError("No more elements");
+    }
+  }
 
-  int next() {
+  bool moveNext() {
+    _current = -1;
     if (utf16EncodedBytesIterator.remaining < 2) {
-      utf16EncodedBytesIterator.next();
+      utf16EncodedBytesIterator.moveNext();
       if (replacementCodepoint != null) {
-        return replacementCodepoint;
+        _current = replacementCodepoint;
+        return true;
       } else {
         throw new ArgumentError(
             "Invalid UTF16 at ${utf16EncodedBytesIterator.position}");
       }
     } else {
-      return decode();
+      _current = decode();
+      return true;
     }
   }
 
   int get position => utf16EncodedBytesIterator.position ~/ 2;
 
   void backup([int by = 1]) {
     utf16EncodedBytesIterator.backup(2 * by);
   }
 
   int get remaining => (utf16EncodedBytesIterator.remaining + 1) ~/ 2;
 
   void skip([int count = 1]) {
     utf16EncodedBytesIterator.skip(2 * count);
   }
 
   abstract int decode();
 }
 
 /**
  * Convert UTF-16BE encoded bytes to utf16 code units by grouping 1-2 bytes
  * to produce the code unit (0-(2^16)-1).
  */
 class Utf16beBytesToCodeUnitsDecoder extends Utf16BytesToCodeUnitsDecoder {
   Utf16beBytesToCodeUnitsDecoder(List<int> utf16EncodedBytes, [
       int offset = 0, int length, bool stripBom = true,
       int replacementCodepoint = UNICODE_REPLACEMENT_CHARACTER_CODEPOINT]) :
-      super._fromListRangeIterator((new _ListRange(utf16EncodedBytes, offset,
-      length)).iterator(), replacementCodepoint) {
+      super._fromListRangeIterator(
+          (new _ListRange(utf16EncodedBytes, offset, length)).iterator,
+          replacementCodepoint) {
     if (stripBom && hasUtf16beBom(utf16EncodedBytes, offset, length)) {
       skip();
     }
   }
 
   int decode() {
-    int hi = utf16EncodedBytesIterator.next();
-    int lo = utf16EncodedBytesIterator.next();
+    utf16EncodedBytesIterator.moveNext();
+    int hi = utf16EncodedBytesIterator.current;
+    utf16EncodedBytesIterator.moveNext();
+    int lo = utf16EncodedBytesIterator.current;
     return (hi << 8) + lo;
   }
 }
 
 /**
  * Convert UTF-16LE encoded bytes to utf16 code units by grouping 1-2 bytes
  * to produce the code unit (0-(2^16)-1).
  */
 class Utf16leBytesToCodeUnitsDecoder extends Utf16BytesToCodeUnitsDecoder {
   Utf16leBytesToCodeUnitsDecoder(List<int> utf16EncodedBytes, [
       int offset = 0, int length, bool stripBom = true,
       int replacementCodepoint = UNICODE_REPLACEMENT_CHARACTER_CODEPOINT]) :
-      super._fromListRangeIterator((new _ListRange(utf16EncodedBytes, offset,
-      length)).iterator(), replacementCodepoint) {
+      super._fromListRangeIterator(
+          (new _ListRange(utf16EncodedBytes, offset, length)).iterator,
+          replacementCodepoint) {
     if (stripBom && hasUtf16leBom(utf16EncodedBytes, offset, length)) {
       skip();
     }
   }
 
   int decode() {
-    int lo = utf16EncodedBytesIterator.next();
-    int hi = utf16EncodedBytesIterator.next();
+    utf16EncodedBytesIterator.moveNext();
+    int lo = utf16EncodedBytesIterator.current;
+    utf16EncodedBytesIterator.moveNext();
+    int hi = utf16EncodedBytesIterator.current;
     return (hi << 8) + lo;
   }
 }