Make Utf8Decoder and Utf8Encoder's convert methods take start and end too.

sdk/lib/convert/utf.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;
 
 /** The Unicode Replacement character `U+FFFD` (�). */
 const int UNICODE_REPLACEMENT_CHARACTER_RUNE = 0xFFFD;
 
 /** The Unicode Byte Order Marker (BOM) character `U+FEFF`. */
@@ skipping 64 matching lines @@
 /**
  * This class converts strings to their UTF-8 code units (a list of
  * unsigned 8-bit integers).
  */
 class Utf8Encoder extends Converter<String, List<int>> {
 
   const Utf8Encoder();
 
   /**
    * Converts [string] to its UTF-8 code units (a list of
    * unsigned 8-bit integers).

[floitsch, 2014/11/19 13:19:58]

Update comment.

    */
-  List<int> convert(String string) {
+  List<int> convert(String string, [int start = 0, int end]) {

[floitsch, 2014/11/19 13:19:58]

Make it named?

[Lasse Reichstein Nielsen, 2014/11/19 13:25:00]

I'd rather not use named parameters. That's a lot more inconvenient to use, and
we generally provide these "range" arguments as positional arguments.

+    int stringLength = string.length;
+    if (start < 0 || start > stringLength) {
+      throw new RangeError.range(start, 0, stringLength, "start");
+    }
+    if (end == null) {
+      end = stringLength;
+    } else if (end < start || end > stringLength) {
+      throw new RangeError.range(end, start, stringLength, "end");
+    }
+    int length = end - start;
+    if (length == 0) return new Uint8List(0);
     // Create a new encoder with a length that is guaranteed to be big enough.
-    // A single code unit uses at most 3 bytes. Two code units at most 4.
-    _Utf8Encoder encoder = new _Utf8Encoder.withBufferSize(string.length * 3);
-    int endPosition = encoder._fillBuffer(string, 0, string.length);
-    assert(endPosition >= string.length - 1);
-    if (endPosition != string.length) {
-      int lastCodeUnit = string.codeUnitAt(string.length - 1);
+    // A single code unit uses at most 3 bytes, a surrogate pair at most 4.
+    _Utf8Encoder encoder = new _Utf8Encoder.withBufferSize(length * 3);
+    int endPosition = encoder._fillBuffer(string, start, end);
+    assert(endPosition >= end - 1);
+    if (endPosition != end) {
+      // Encoding skipped the last code unit.
+      // That can only happen if the last code unit is a leadsurrogate.
+      // Force encoding of the lead surrogate by itself.
+      int lastCodeUnit = string.codeUnitAt(end - 1);
       assert(_isLeadSurrogate(lastCodeUnit));
       // We use a non-surrogate as `nextUnit` so that _writeSurrogate just
       // writes the lead-surrogate.
       bool wasCombined = encoder._writeSurrogate(lastCodeUnit, 0);
       assert(!wasCombined);
     }
     return encoder._buffer.sublist(0, encoder._bufferIndex);
   }
 
   /**
@@ skipping 201 matching lines @@
    * sequences with the Unicode Replacement character `U+FFFD` (�). Otherwise
    * it throws a [FormatException].
    */
   const Utf8Decoder({ bool allowMalformed: false })
       : this._allowMalformed = allowMalformed;
 
   /**
    * Converts the UTF-8 [codeUnits] (a list of unsigned 8-bit integers) to the
    * corresponding string.
    *
+   * Uses the code units from [start] to, but no including, [end].
+   * If [end] is omitted, it defaults to `codeUnits.length`.
+   *
    * If the [codeUnits] start with a leading [UNICODE_BOM_CHARACTER_RUNE] this
    * character is discarded.
    */
-  String convert(List<int> codeUnits) {
+  String convert(List<int> codeUnits, [int start = 0, int end]) {

[floitsch, 2014/11/19 13:19:57]

ditto.

+    int length = codeUnits.length;
+    if (start < 0 || start > length) {
+      throw new RangeError.range(start, 0, length, "start");
+    }
+    if (end == null) {
+      end = length;
+    } else if (end < start || end > length) {
+      throw new RangeError.range(end, start, length, "end");
+    }
     StringBuffer buffer = new StringBuffer();
     _Utf8Decoder decoder = new _Utf8Decoder(buffer, _allowMalformed);
-    decoder.convert(codeUnits, 0, codeUnits.length);
+    decoder.convert(codeUnits, start, end);
     decoder.close();
     return buffer.toString();
   }
 
   /**
    * Starts a chunked conversion.
    *
    * The converter works more efficiently if the given [sink] is a
    * [StringConversionSink].
    */
@@ skipping 205 matching lines @@
       }
       break loop;
     }
     if (expectedUnits > 0) {
       _value = value;
       _expectedUnits = expectedUnits;
       _extraUnits = extraUnits;
     }
   }
 }