Fix unresolved classes issues in dart:io.

sdk/lib/scalarlist/byte_arrays.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.
 
 /**
  * A random-access sequence of bytes that also provides random access to
  * the fixed-width integers and floating point numbers represented by
  * those bytes. Byte arrays may be used to pack and unpack data from
  * external sources (such as networks or files systems), and to process
  * large quantities of numerical data more efficiently than would be possible
@@ skipping 351 matching lines @@
   external factory Int8List(int length);
 
   /**
    * Creates an [Int8List] _view_ of the specified region in the specified
    * byte [array]. Changes in the [Int8List] will be visible in the byte
    * array and vice versa. If the [start] index of the region is not specified,
    * it defaults to zero (the first byte in the byte array). If the length is
    * not specified, it defaults to null, which indicates that the view extends
    * to the end of the byte array.
    */
-  external factory Int8List.view(ByteArray array, [int start, int length]);
+  external factory Int8List.view(ByteArray array, [int start = 0, int length]);
 }
 
 
 /**
  * A fixed-length list of 8-bit unsigned integers that is viewable as a
  * [ByteArray]. For long lists, this implementation will be considerably
  * more space- and time-efficient than the default [List] implementation.
  */
 abstract class Uint8List implements List<int>, ByteArrayViewable {
   /**
    * Creates a [Uint8List] of the specified length (in elements), all of
    * whose elements are initially zero.
    */
   external factory Uint8List(int length);
 
   /**
    * Creates a [Uint8List] _view_ of the specified region in the specified
    * byte [array]. Changes in the [Uint8List] will be visible in the byte
    * array and vice versa. If the [start] index of the region is not specified,
    * it defaults to zero (the first byte in the byte array). If the length is
    * not specified, it defaults to null, which indicates that the view extends
    * to the end of the byte array.
    */
-  external factory Uint8List.view(ByteArray array, [int start, int length]);
+  external factory Uint8List.view(ByteArray array, [int start = 0, int length]);
 }
 
 
 /**
  * A fixed-length list of 8-bit unsigned integers that is viewable as a
  * [ByteArray]. For long lists, this implementation will be considerably
  * more space- and time-efficient than the default [List] implementation.
  * Indexed store clamps the value to range 0..0xFF.
  */
 abstract class Uint8ClampedList implements List<int>, ByteArrayViewable {
   /**
    * Creates a [Uint8ClampedList] of the specified length (in elements), all of
    * whose elements are initially zero.
    */
   external factory Uint8ClampedList(int length);
 
   /**
    * Creates a [Uint8ClampedList] _view_ of the specified region in the
    * specified byte [array]. Changes in the [Uint8List] will be visible in the
    * byte array and vice versa. If the [start] index of the region is not
    * specified, it defaults to zero (the first byte in the byte array). If the
    * length is not specified, it defaults to null, which indicates that the view
    * extends to the end of the byte array.
    */
   external factory Uint8ClampedList.view(ByteArray array,
-                                         [int start, int length]);
+                                         [int start = 0, int length]);
 }
 
 
 /**
  * A fixed-length list of 16-bit signed integers that is viewable as a
  * [ByteArray]. For long lists, this implementation will be considerably
  * more space- and time-efficient than the default [List] implementation.
  */
 abstract class Int16List implements List<int>, ByteArrayViewable {
   /**
@@ skipping 13 matching lines @@
    * Throws [ArgumentError] if the length of the specified region
    * is not divisible by 2 (the size of an "int16" in bytes), or if the
    * [start] of the region is not divisible by 2. If, however, [array]
    * is a view of another byte array, this constructor will throw
    * [ArgumentError] if the implicit starting position in the
    * "ultimately backing" byte array is not divisible by 2. In plain terms,
    * this constructor throws [ArgumentError] if the specified
    * region does not contain an integral number of "int16s," or if it
    * is not "int16-aligned."
    */
-  external factory Int16List.view(ByteArray array, [int start, int length]);
+  external factory Int16List.view(ByteArray array, [int start = 0, int length]);
 }
 
 
 /**
  * A fixed-length list of 16-bit unsigned integers that is viewable as a
  * [ByteArray]. For long lists, this implementation will be considerably
  * more space- and time-efficient than the default [List] implementation.
  */
 abstract class Uint16List implements List<int>, ByteArrayViewable {
   /**
@@ skipping 13 matching lines @@
    * Throws [ArgumentError] if the length of the specified region
    * is not divisible by 2 (the size of a "uint16" in bytes), or if the
    * [start] of the region is not divisible by 2. If, however, [array]
    * is a view of another byte array, this constructor will throw
    * [ArgumentError] if the implicit starting position in the
    * "ultimately backing" byte array is not divisible by 2. In plain terms,
    * this constructor throws [ArgumentError] if the specified
    * region does not contain an integral number of "uint16s," or if it
    * is not "uint16-aligned."
    */
-  external factory Uint16List.view(ByteArray array, [int start, int length]);
+  external factory Uint16List.view(ByteArray array,
+                                   [int start = 0, int length]);
 }
 
 
 /**
  * A fixed-length list of 32-bit signed integers that is viewable as a
  * [ByteArray]. For long lists, this implementation will be considerably
  * more space- and time-efficient than the default [List] implementation.
  */
 abstract class Int32List implements List<int>, ByteArrayViewable {
   /**
@@ skipping 13 matching lines @@
    * Throws [ArgumentError] if the length of the specified region
    * is not divisible by 4 (the size of an "int32" in bytes), or if the
    * [start] of the region is not divisible by 4. If, however, [array]
    * is a view of another byte array, this constructor will throw
    * [ArgumentError] if the implicit starting position in the
    * "ultimately backing" byte array is not divisible by 4. In plain terms,
    * this constructor throws [ArgumentError] if the specified
    * region does not contain an integral number of "int32s," or if it
    * is not "int32-aligned."
    */
-  external factory Int32List.view(ByteArray array, [int start, int length]);
+  external factory Int32List.view(ByteArray array, [int start = 0, int length]);
 }
 
 
 /**
  * A fixed-length list of 32-bit unsigned integers that is viewable as a
  * [ByteArray]. For long lists, this implementation will be considerably
  * more space- and time-efficient than the default [List] implementation.
  */
 abstract class Uint32List implements List<int>, ByteArrayViewable {
   /**
@@ skipping 13 matching lines @@
    * Throws [ArgumentError] if the length of the specified region
    * is not divisible by 4 (the size of a "uint32" in bytes), or if the
    * [start] of the region is not divisible by 4. If, however, [array]
    * is a view of another byte array, this constructor will throw
    * [ArgumentError] if the implicit starting position in the
    * "ultimately backing" byte array is not divisible by 4. In plain terms,
    * this constructor throws [ArgumentError] if the specified
    * region does not contain an integral number of "uint32s," or if it
    * is not "uint32-aligned."
    */
-  external factory Uint32List.view(ByteArray array, [int start, int length]);
+  external factory Uint32List.view(ByteArray array,
+                                   [int start = 0, int length]);
 }
 
 
 /**
  * A fixed-length list of 64-bit signed integers that is viewable as a
  * [ByteArray]. For long lists, this implementation will be considerably
  * more space- and time-efficient than the default [List] implementation.
  */
 abstract class Int64List implements List<int>, ByteArrayViewable {
   /**
@@ skipping 13 matching lines @@
    * Throws [ArgumentError] if the length of the specified region
    * is not divisible by 8 (the size of an "int64" in bytes), or if the
    * [start] of the region is not divisible by 8. If, however, [array]
    * is a view of another byte array, this constructor will throw
    * [ArgumentError] if the implicit starting position in the
    * "ultimately backing" byte array is not divisible by 8. In plain terms,
    * this constructor throws [ArgumentError] if the specified
    * region does not contain an integral number of "int64s," or if it
    * is not "int64-aligned."
    */
-  external factory Int64List.view(ByteArray array, [int start, int length]);
+  external factory Int64List.view(ByteArray array, [int start = 0, int length]);
 }
 
 
 /**
  * A fixed-length list of 64-bit unsigned integers that is viewable as a
  * [ByteArray]. For long lists, this implementation will be considerably
  * more space- and time-efficient than the default [List] implementation.
  */
 abstract class Uint64List implements List<int>, ByteArrayViewable {
   /**
@@ skipping 13 matching lines @@
    * Throws [ArgumentError] if the length of the specified region
    * is not divisible by 8 (the size of a "uint64" in bytes), or if the
    * [start] of the region is not divisible by 8. If, however, [array]
    * is a view of another byte array, this constructor will throw
    * [ArgumentError] if the implicit starting position in the
    * "ultimately backing" byte array is not divisible by 8. In plain terms,
    * this constructor throws [ArgumentError] if the specified
    * region does not contain an integral number of "uint64s," or if it
    * is not "uint64-aligned."
    */
-  external factory Uint64List.view(ByteArray array, [int start, int length]);
+  external factory Uint64List.view(ByteArray array,
+                                   [int start = 0, int length]);
 }
 
 
 /**
  * A fixed-length list of IEEE 754 single-precision binary floating-point
  * numbers  that is viewable as a [ByteArray]. For long lists, this
  * implementation will be considerably more space- and time-efficient than
  * the default [List] implementation.
  */
 abstract class Float32List implements List<double>, ByteArrayViewable {
@@ skipping 14 matching lines @@
    * Throws [ArgumentError] if the length of the specified region
    * is not divisible by 4 (the size of a "float32" in bytes), or if the
    * [start] of the region is not divisible by 4. If, however, [array]
    * is a view of another byte array, this constructor will throw
    * [ArgumentError] if the implicit starting position in the
    * "ultimately backing" byte array is not divisible by 4. In plain terms,
    * this constructor throws [ArgumentError] if the specified
    * region does not contain an integral number of "float32s," or if it
    * is not "float32-aligned."
    */
-  external factory Float32List.view(ByteArray array, [int start, int length]);
+  external factory Float32List.view(ByteArray array,
+                                    [int start = 0, int length]);
 }
 
 
 /**
  * A fixed-length list of IEEE 754 double-precision binary floating-point
  * numbers  that is viewable as a [ByteArray]. For long lists, this
  * implementation will be considerably more space- and time-efficient than
  * the default [List] implementation.
  */
 abstract class Float64List implements List<double>, ByteArrayViewable {
@@ skipping 14 matching lines @@
    * Throws [ArgumentError] if the length of the specified region
    * is not divisible by 8 (the size of a "float64" in bytes), or if the
    * [start] of the region is not divisible by 8. If, however, [array]
    * is a view of another byte array, this constructor will throw
    * [ArgumentError] if the implicit starting position in the
    * "ultimately backing" byte array is not divisible by 8. In plain terms,
    * this constructor throws [ArgumentError] if the specified
    * region does not contain an integral number of "float64s," or if it
    * is not "float64-aligned."
    */
-  external factory Float64List.view(ByteArray array, [int start, int length]);
+  external factory Float64List.view(ByteArray array,
+                                    [int start = 0, int length]);
 }