Rename blahHandler to onBlah throughout dart:io.

runtime/bin/file.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.
 
 
 /**
  * FileMode describes the modes in which a file can be opened.
  */
 class FileMode {
   static final READ = const FileMode(0);
@@ skipping 11 matching lines @@
  * streams using [openInputStream] and [openOutputStream] or open the
  * file for random access operations using [open].
  */
 interface File default _File {
   /**
    * Create a File object.
    */
   File(String name);
 
   /**
-   * Check if the file exists. The [existsHandler] is called with the
-   * result when the operation completes.
+   * Check if the file exists. [onExists] is called with the result
+   * when the operation completes.
    */
   void exists();
 
   /**
    * Synchronously check if the file exists.
    */
   bool existsSync();
 
   /**
-   * Create the file. The [createHandler] is called when the file has
-   * been created. The [errorHandler] is called if the file cannot be
+   * Create the file. [onCreate] is called when the file has been
+   * created. [onError] is called if the file cannot be
    * created. Existing files are left untouched by create. Calling
    * create on an existing file might fail if there are restrictive
    * permissions on the file.
    */
   void create();
 
   /**
    * Synchronously create the file. Existing files are left untouched
    * by create. Calling create on an existing file might fail if there
    * are restrictive permissions on the file.
    */
   void createSync();
 
   /**
-   * Delete the file. The [deleteHandler] is called when the file has
-   * been successfully deleted. The [errorHandler] is called if the
-   * file cannot be deleted.
+   * Delete the file. [onDelete] is called when the file has been
+   * successfully deleted. [onError] is called if the file cannot be
+   * deleted.
    */
   void delete();
 
   /**
    * Synchronously delete the file.
    */
   void deleteSync();
 
   /**
    * Get a Directory object for the directory containing this file. If
-   * the file does not exist the [errorHandler] is called. When the
-   * operation completes the [directoryHandler] is called with the
-   * result.
+   * the file does not exist [onError] is called. When the operation
+   * completes [onDirectory] is called with the result.
    */
   void directory();
 
   /**
    * Synchronously get a Directory object for the directory containing
    * this file.
    */
   Directory directorySync();
 
   /**
    * Open the file for random access operations. When the file is
-   * opened the [openHandler] is called with the resulting
+   * opened [onOpen] is called with the resulting
    * RandomAccessFile. RandomAccessFiles must be closed using the
-   * [close] method. If the file cannot be opened the [errorHandler]
-   * is called.
+   * [close] method. If the file cannot be opened [onError] is called.
    *
    * Files can be opened in three modes:
    *
    * FileMode.READ: open the file for reading. If the file does not
-   * exist the [errorHandler] is called.
+   * exist [onError] is called.
    *
    * FileMode.WRITE: open the file for both reading and writing and
    * truncate the file to length zero. If the file does not exist the
    * file is created.
    *
    * FileMode.APPEND: same as FileMode.WRITE except that the file is
    * not truncated.
    *
    * By default mode is FileMode.READ.
    */
   void open([FileMode mode]);
 
   /**
    * Synchronously open the file for random access operations. The
    * result is a RandomAccessFile on which random access operations
    * can be performed. Opened RandomAccessFiles must be closed using
    * the [close] method.
    *
    * See [open] for information on the [:mode:] argument.
    */
   RandomAccessFile openSync([FileMode mode]);
 
   /**
-   * Get the canonical full path corresponding to the file name. The
-   * [fullPathHandler] is called with the result when the fullPath
+   * Get the canonical full path corresponding to the file name.
+   * [onFullPath] is called with the result when the fullPath
    * operation completes.
    */
   void fullPath();
 
   /**
    * Synchronously get the canonical full path corresponding to the file name.
    */
   String fullPathSync();
 
   /**
@@ skipping 15 matching lines @@
    *
    * FileMode.APPEND: create the stream and set the position to the end of
    * the underlying file.
    *
    * By default the mode is FileMode.WRITE.
    */
   OutputStream openOutputStream([FileMode mode]);
 
   /**
    * Read the entire file contents as a list of bytes. When the
-   * operation completes the [readAsBytesHandler] is called.
-   * The [errorHandler] is called if the operation fails.
+   * operation completes [onReadAsBytes] is called. [onError] is
+   * called if the operation fails.
    */
   void readAsBytes();
 
   /**
    * Synchronously read the entire file contents as a list of bytes.
    */
   List<int> readAsBytesSync();
 
   /**
    * Read the entire file contents as text using the given [encoding]
    * ('UTF-8', 'ISO-8859-1', 'ASCII'). By default the encoding is
    * 'UTF-8'.
    *
-   * When the operation completes the [readAsTextHandler] is called
-   * with the resulting string.  The [errorHandler] is called if the
-   * operation fails.
+   * When the operation completes [onReadAsText] is called with the
+   * resulting string. [onError] is called if the operation fails.
    */
   void readAsText([String encoding]);
 
   /**
    * Synchronously read the entire file contents as text using the
    * given [encoding] ('UTF-8', 'ISO-8859-1', 'ASCII'). By default the
    * encoding is 'UTF-8'.
    */
   String readAsTextSync([String encoding]);
 
   /**
    * Read the entire file contents as lines of text using the give
    * [encoding] ('UTF-8', 'ISO-8859-1', 'ASCII'). By default the
    * encoding is 'UTF-8'.
    *
-   * When the operation completes the [readAsLinesHandler] is called
-   * with the resulting string.  The [errorHandler] is called if the
-   * operation fails.
+   * When the operation completes [onReadAsLines] is called with the
+   * resulting string. [onError] is called if the operation fails.
    */
   void readAsLines();
 
   /**
    * Synchronously read the entire file contents as lines of text
    * using the given [encoding] ('UTF-8', 'ISO-8859-1', 'ASCII'). By
    * default the encoding is 'UTF-8'.
    */
   List<String> readAsLinesSync([String encoding]);
 
   /**
    * Get the name of the file.
    */
   String get name();
 
   /**
    * Sets the handler that gets called when an [exists] operation
    * completes.
    */
-  void set existsHandler(void handler(bool exists));
+  void set onExists(void handler(bool exists));
 
   /**
    * Sets the handler that gets called when a [create] operation
    * completes.
    */
-  void set createHandler(void handler());
+  void set onCreate(void handler());

[Søren Gjesse, 2012/02/29 07:41:24]

onCreated?

 
   /**
    * Sets the handler that gets called when a [delete] operation
    * completes.
    */
-  void set deleteHandler(void handler());
+  void set onDelete(void handler());

[Søren Gjesse, 2012/02/29 07:41:24]

onDeleted?

 
   /**
    * Sets the handler that gets called when a [directory] operation
    * completes.
    */
-  void set directoryHandler(void handler(Directory directory));
+  void set onDirectory(void handler(Directory directory));
 
   /**
    * Sets the handler that gets called when an [open] operation
    * completes.
    */
-  void set openHandler(void handler(RandomAccessFile openedFile));
+  void set onOpen(void handler(RandomAccessFile openedFile));

[Søren Gjesse, 2012/02/29 07:41:24]

OnOpened?

 
   /**
    * Set the handler that gets called when a [readAsBytes] operation
    * completes.
    */
-  void set readAsBytesHandler(void handler(List<int> bytes));
+  void set onReadAsBytes(void handler(List<int> bytes));
 
   /**
    * Set the handler that gets called when a [readAsText] operation
    * completes.
    */
-  void set readAsTextHandler(void handler(String text));
+  void set onReadAsText(void handler(String text));
 
   /**
    * Set the handler that gets called when a [readAsLines] operation
    * completes.
    */
-  void set readAsLinesHandler(void handler(List<String> lines));
+  void set onReadAsLines(void handler(List<String> lines));
 
   /**
    * Sets the handler that gets called when a [fullPath] operation
    * completes.
    */
-  void set fullPathHandler(void handler(String path));
+  void set onFullPath(void handler(String path));
 
   /**
    * Sets the handler that gets called when errors occur during
    * operations on this file.
    */
-  void set errorHandler(void handler(String error));
+  void set onError(void handler(String error));
 }
 
 
 /**
  * [RandomAccessFile] provides random access to the data in a
  * file. [RandomAccessFile] objects are obtained by calling the
  * [:open:] method on a [File] object.
  */
 interface RandomAccessFile {
   /**
-   * Close the file. When the file is closed the [closeHandler] is
-   * called.
+   * Close the file. When the file is closed [onClose] is called.
    */
   void close();
 
   /**
    * Synchronously close the file.
    */
   void closeSync();
 
   /**
    * Read a byte from the file. When the byte has been read the
-   * [readByteHandler] is called with the value.
+   * [onReadByte] is called with the value.
    */
   void readByte();
 
   /**
    * Synchronously read a single byte from the file.
    */
   int readByteSync();
 
   /**
    * Read a List<int> from the file. When the list has been read the
-   * [readListHandler] is called with an integer indicating how much
+   * [onReadList] is called with an integer indicating how much
    * was read.
    */
   void readList(List<int> buffer, int offset, int bytes);
 
   /**
    * Synchronously read a List<int> from the file. Returns the number
    * of bytes read.
    */
   int readListSync(List<int> buffer, int offset, int bytes);
 
   /**
    * Write a single byte to the file. If the byte cannot be written
-   * the [errorHandler] is called. When all pending write operations
-   * have finished the [noPendingWriteHandler] is called.
+   * [onError] is called. When all pending write operations have
+   * finished [onNoPendingWrite] is called.
    */
   void writeByte(int value);
 
   /**
    * Synchronously write a single byte to the file. Returns the
    * number of bytes successfully written.
    */
   int writeByteSync(int value);
 
   /**
    * Write a List<int> to the file. If the list cannot be written the
-   * [errorHandler] is called. When all pending write operations have
-   * finished the [noPendingWriteHandler] is called.
+   * [onError] is called. When all pending write operations have
+   * finished [onNoPendingWrite] is called.
    */
   void writeList(List<int> buffer, int offset, int bytes);
 
   /**
    * Synchronously write a List<int> to the file. Returns the number
    * of bytes successfully written.
    */
   int writeListSync(List<int> buffer, int offset, int bytes);
 
   /**
    * Write a string to the file. If the string cannot be written the
-   * [errorHandler] is called. When all pending write operations have
-   * finished the [noPendingWriteHandler] is called.
+   * [onError] is called. When all pending write operations have
+   * finished [onNoPendingWrite] is called.
    */
   // TODO(ager): writeString should take an encoding.
   void writeString(String string);
 
   /**
    * Synchronously write a single string to the file. Returns the number
    * of characters successfully written.
    */
   // TODO(ager): writeStringSync should take an encoding.
   int writeStringSync(String string);
 
   /**
    * Get the current byte position in the file. When the operation
-   * completes the [positionHandler] is called with the position.
+   * completes [onPosition] is called with the position.
    */
   void position();
 
   /**
    * Synchronously get the current byte position in the file.
    */
   int positionSync();
 
   /**
    * Set the byte position in the file. When the operation completes
-   * the [setPositionHandler] is called.
+   * [onSetPosition] is called.
    */
   void setPosition(int position);
 
   /**
    * Synchronously set the byte position in the file.
    */
   void setPositionSync(int position);
 
   /**
    * Truncate (or extend) the file to [length] bytes. When the
-   * operation completes successfully the [truncateHandler] is called.
+   * operation completes successfully [onTruncate] is called.
    */
   void truncate(int length);
 
   /**
    * Synchronously truncate (or extend) the file to [length] bytes.
    */
   void truncateSync(int length);
 
   /**
    * Get the length of the file. When the operation completes the
-   * [lengthHandler] is called with the length.
+   * [onLength] is called with the length.
    */
   void length();
 
   /**
    * Synchronously get the length of the file.
    */
   int lengthSync();
 
   /**
-   * Flush the contents of the file to disk. The [flushHandler] is
+   * Flush the contents of the file to disk. [onOnFlush] is
    * called when the flush operation completes.
    */
    void flush();
 
   /**
    * Synchronously flush the contents of the file to disk.
    */
   void flushSync();
 
   /**
    * Get the name of the file.
    */
   String get name();
 
   /**
    * Sets the handler that gets called when a [close] operation
    * completes.
    */
-  void set closeHandler(void handler());
+  void set onClose(void handler());
 
   /**
    * Sets the handler that gets called when a [readByte] operation
    * completes.
    */
-  void set readByteHandler(void handler(int byte));
+  void set onReadByte(void handler(int byte));

[Søren Gjesse, 2012/02/29 07:41:24]

onByteRead?

 
   /**
    * Sets the handler that gets called when a [readList] operation
    * completes.
    */
-  void set readListHandler(void handler(int read));
+  void set onReadList(void handler(int read));

[Søren Gjesse, 2012/02/29 07:41:24]

onListRead?

 
   /**
    * Sets the handler that gets called when there are no more write
    * operations pending for this file.
    */
-  void set noPendingWriteHandler(void handler());
+  void set onNoPendingWrite(void handler());

[Søren Gjesse, 2012/02/29 07:41:24]

onNoPendingWrites (with an s)?

 
   /**
    * Sets the handler that gets called when a [position] operation
    * completes.
    */
-  void set positionHandler(void handler(int position));
+  void set onPosition(void handler(int position));
 
   /**
    * Sets the handler that gets called when a [setPosition] operation
    * completes.
    */
-  void set setPositionHandler(void handler());
+  void set onSetPosition(void handler());

[Søren Gjesse, 2012/02/29 07:41:24]

OnPositionSet?

 
   /**
    * Sets the handler that gets called when a [truncate] operation
    * completes.
    */
-  void set truncateHandler(void handler());
+  void set onTruncate(void handler());

[Søren Gjesse, 2012/02/29 07:41:24]

OnTruncated?

 
   /**
    * Sets the handler that gets called when a [length] operation
    * completes.
    */
-  void set lengthHandler(void handler(int length));
+  void set onLength(void handler(int length));
 
   /**
    * Sets the handler that gets called when a [flush] operation
    * completes.
    */
-  void set flushHandler(void handler());
+  void set onFlush(void handler());

[Søren Gjesse, 2012/02/29 07:41:24]

onFlushed?

 
   /**
    * Sets the handler that gets called when errors occur when
    * operating on this file.
    */
-  void set errorHandler(void handler(String error));
+  void set onError(void handler(String error));
 }
 
 
 class FileIOException implements Exception {
   const FileIOException([String this.message = ""]);
   String toString() => "FileIOException: $message";
   final String message;
 }