Rename RandomAccessFile.readList and RandomAccessFile.writeList to RandomAccessFile.readInto and Ra…

sdk/lib/io/file_impl.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;
 
 // Read the file in blocks of size 64k.
 const int _BLOCK_SIZE = 64 * 1024;
 
 
@@ skipping 150 matching lines @@
     _openFuture = new Future.immediate(_File._openStdioSync(fd));
   }
 
   Future<File> addStream(Stream<List<int>> stream) {
     Completer<File> completer = new Completer<File>();
     _openFuture
       .then((openedFile) {
         _subscription = stream.listen(
           (d) {
             _subscription.pause();
-            openedFile.writeList(d, 0, d.length)
+            openedFile.writeFrom(d, 0, d.length)
               .then((_) => _subscription.resume())
               .catchError((e) {
                 openedFile.close();
                 completer.completeError(e);
               });
           },
           onDone: () {
             completer.complete(_file);
           },
           onError: (e) {
@@ skipping 374 matching lines @@
       sink.add(bytes);
       sink.close();
       return sink.done.then((_) => this);;
     } catch (e) {
       return new Future.immediateError(e);
     }
   }
 
   void writeAsBytesSync(List<int> bytes, {FileMode mode: FileMode.WRITE}) {
     RandomAccessFile opened = openSync(mode: mode);
-    opened.writeListSync(bytes, 0, bytes.length);
+    opened.writeFromSync(bytes, 0, bytes.length);
     opened.closeSync();
   }
 
   Future<File> writeAsString(String contents,
                              {FileMode mode: FileMode.WRITE,
                               Encoding encoding: Encoding.UTF_8}) {
     try {
       return writeAsBytes(_encodeString(contents, encoding), mode: mode);
     } catch (e) {
       var completer = new Completer();
@@ skipping 127 matching lines @@
           "Invalid arguments to readSync for file '$_path'");
     }
     var result = _read(_id, bytes);
     if (result is OSError) {
       throw new FileIOException("readSync failed for file '$_path'",
                                 result);
     }
     return result;
   }
 
-  Future<int> readList(List<int> buffer, int offset, int bytes) {
+  Future<int> readInto(List<int> buffer, [int start, int end]) {
     _ensureFileService();
+    if (buffer is !List ||
+        (start != null && start is !int) ||
+        (end != null && end is !int)) {
+      return new Future.immediateError(new FileIOException(
+          "Invalid arguments to readInto for file '$_path'"));
+    };
     Completer<int> completer = new Completer<int>();
-    if (buffer is !List || offset is !int || bytes is !int) {
-      // Complete asynchronously so the user has a chance to setup
-      // handlers without getting exceptions when registering the
-      // then handler.
-      Timer.run(() {
-        completer.completeError(new FileIOException(
-            "Invalid arguments to readList for file '$_path'"));
-      });
-      return completer.future;
-    };
     if (closed) return _completeWithClosedException(completer);
     List request = new List(3);
+    if (start == null) start = 0;
+    if (end == null) end = buffer.length;
     request[0] = _READ_LIST_REQUEST;
     request[1] = _id;
-    request[2] = bytes;
+    request[2] = end - start;
     return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
-                                     "readList failed for file '$_path'");
+                                     "readInto failed for file '$_path'");
       }
       var read = response[1];
       var data = response[2];
-      buffer.setRange(offset, read, data);
+      buffer.setRange(start, read, data);
       return read;
     });
   }
 
-  static void _checkReadWriteListArguments(int length, int offset, int bytes) {
-    if (offset < 0) throw new RangeError.value(offset);
-    if (bytes < 0) throw new RangeError.value(bytes);
-    if ((offset + bytes) > length) {
-      throw new RangeError.value(offset + bytes);
+  static void _checkReadWriteListArguments(int length, int start, int end) {
+    if (start < 0) throw new RangeError.value(start);
+    if (end < start) throw new RangeError.value(end);
+    if (end > length) {
+      throw new RangeError.value(end);
     }
   }
 
-  external static _readList(int id, List<int> buffer, int offset, int bytes);
+  external static _readInto(int id, List<int> buffer, int start, int end);
 
-  int readListSync(List<int> buffer, int offset, int bytes) {
+  int readIntoSync(List<int> buffer, [int start, int end]) {
     _checkNotClosed();
-    if (buffer is !List || offset is !int || bytes is !int) {
+    if (buffer is !List ||
+        (start != null && start is !int) ||
+        (end != null && end is !int)) {
       throw new FileIOException(
-          "Invalid arguments to readList for file '$_path'");
+          "Invalid arguments to readInto for file '$_path'");
     }
-    if (bytes == 0) return 0;
-    _checkReadWriteListArguments(buffer.length, offset, bytes);
-    var result = _readList(_id, buffer, offset, bytes);
+    if (start == null) start = 0;
+    if (end == null) end = buffer.length;
+    if (end == start) return 0;
+    _checkReadWriteListArguments(buffer.length, start, end);
+    var result = _readInto(_id, buffer, start, end);
     if (result is OSError) {
-      throw new FileIOException("readList failed for file '$_path'",
+      throw new FileIOException("readInto failed for file '$_path'",
                                 result);
     }
     return result;
   }
 
   Future<RandomAccessFile> writeByte(int value) {
     _ensureFileService();
     Completer<RandomAccessFile> completer = new Completer<RandomAccessFile>();
     if (value is !int) {
       // Complete asynchronously so the user has a chance to setup
@@ skipping 28 matching lines @@
           "Invalid argument to writeByte for file '$_path'");
     }
     var result = _writeByte(_id, value);
     if (result is OSError) {
       throw new FileIOException("writeByte failed for file '$_path'",
                                 result);
     }
     return result;
   }
 
-  Future<RandomAccessFile> writeList(List<int> buffer, int offset, int bytes) {
+  Future<RandomAccessFile> writeFrom(List<int> buffer, [int start, int end]) {
     _ensureFileService();
+    if (buffer is !List ||
+        (start != null && start is !int) ||
+        (end != null && end is !int)) {
+      return new Future.immediateError(new FileIOException(
+          "Invalid arguments to writeFrom for file '$_path'"));
+    }
     Completer<RandomAccessFile> completer = new Completer<RandomAccessFile>();
-    if (buffer is !List || offset is !int || bytes is !int) {
-      // Complete asynchronously so the user has a chance to setup
-      // handlers without getting exceptions when registering the
-      // then handler.
-      Timer.run(() {
-          completer.completeError(new FileIOException(
-          "Invalid arguments to writeList for file '$_path'"));
-      });
-      return completer.future;
-    }
+
     if (closed) return _completeWithClosedException(completer);
 
-    _BufferAndOffset result;
+    _BufferAndStart result;
     try {
-      result = _ensureFastAndSerializableBuffer(buffer, offset, bytes);
+      result = _ensureFastAndSerializableBuffer(buffer, start, end);
     } catch (e) {
-      // Complete asynchronously so the user has a chance to setup
-      // handlers without getting exceptions when registering the
-      // then handler.
-      Timer.run(() => completer.completeError(e));
-      return completer.future;
+      return new Future.immediateError(e);
     }
 
     List request = new List(5);
     request[0] = _WRITE_LIST_REQUEST;
     request[1] = _id;
     request[2] = result.buffer;
-    request[3] = result.offset;
-    request[4] = bytes;
+    request[3] = result.start;
+    request[4] = end - (start - result.start);
     return _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
-                                     "writeList failed for file '$_path'");
+                                     "writeFrom failed for file '$_path'");
       }
       return this;
     });
   }
 
-  external static _writeList(int id, List<int> buffer, int offset, int bytes);
+  external static _writeFrom(int id, List<int> buffer, int start, int end);
 
-  int writeListSync(List<int> buffer, int offset, int bytes) {
+  void writeFromSync(List<int> buffer, [int start, int end]) {
     _checkNotClosed();
-    if (buffer is !List || offset is !int || bytes is !int) {
+    if (buffer is !List ||
+        (start != null && start is !int) ||
+        (end != null && end is !int)) {
       throw new FileIOException(
-          "Invalid arguments to writeList for file '$_path'");
+          "Invalid arguments to writeFrom for file '$_path'");
     }
-    if (bytes == 0) return 0;
-    _checkReadWriteListArguments(buffer.length, offset, bytes);
-    _BufferAndOffset bufferAndOffset =
-        _ensureFastAndSerializableBuffer(buffer, offset, bytes);
-    var result =
-      _writeList(_id, bufferAndOffset.buffer, bufferAndOffset.offset, bytes);
+    if (start == null) start = 0;
+    if (end == null) end = buffer.length;
+    if (end == start) return;
+    _checkReadWriteListArguments(buffer.length, start, end);
+    _BufferAndStart bufferAndStart =
+        _ensureFastAndSerializableBuffer(buffer, start, end);
+    var result = _writeFrom(_id,
+                            bufferAndStart.buffer,
+                            bufferAndStart.start,
+                            end - (start - bufferAndStart.start));
     if (result is OSError) {
-      throw new FileIOException("writeList failed for file '$_path'", result);
+      throw new FileIOException("writeFrom failed for file '$_path'", result);
     }
-    return result;
   }
 
   Future<RandomAccessFile> writeString(String string,
                                        {Encoding encoding: Encoding.UTF_8}) {
     if (encoding is! Encoding) {
       var completer = new Completer();
       Timer.run(() {
         completer.completeError(new FileIOException(
             "Invalid encoding in writeString: $encoding"));
       });
       return completer.future;
     }
     var data = _encodeString(string, encoding);
-    return writeList(data, 0, data.length);
+    return writeFrom(data, 0, data.length);
   }
 
-  int writeStringSync(String string, {Encoding encoding: Encoding.UTF_8}) {
+  void writeStringSync(String string, {Encoding encoding: Encoding.UTF_8}) {
     if (encoding is! Encoding) {
       throw new FileIOException(
           "Invalid encoding in writeStringSync: $encoding");
     }
     var data = _encodeString(string, encoding);
-    return writeListSync(data, 0, data.length);
+    writeFromSync(data, 0, data.length);
   }
 
   Future<int> position() {
     _ensureFileService();
     Completer<int> completer = new Completer<int>();
     if (closed) return _completeWithClosedException(completer);
     List request = new List(2);
     request[0] = _POSITION_REQUEST;
     request[1] = _id;
     return _fileService.call(request).then((response) {
@@ skipping 145 matching lines @@
           new FileIOException("File closed '$_path'"));
     });
     return completer.future;
   }
 
   final String _path;
   int _id;
 
   SendPort _fileService;
 }