dart:io | Add asynchronous versions of the methods of FileSystemEntity and Link.

sdk/lib/io/file_system_entity.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;
 
 class FileSystemEntityType {
   static const FILE = const FileSystemEntityType._internal(0);
   static const DIRECTORY = const FileSystemEntityType._internal(1);
   static const LINK = const FileSystemEntityType._internal(2);
@@ skipping 25 matching lines @@
 
   external static int _getType(String path, bool followLinks);
   external static bool _identical(String path1, String path2);
 
   static int _getTypeSync(String path, bool followLinks) {
     var result = _getType(path, followLinks);
     _throwIfError(result, 'Error getting type of FileSystemEntity');
     return result;
   }
 
+  static Future<int> _getTypeAsync(String path, bool followLinks) =>
+      new Future(() => _getTypeSync(path, followLinks));

[Søren Gjesse, 2013/05/03 07:13:36]

This still needs to be calling a service finction on the native thread to be
truly async.

[Bill Hesse, 2013/05/03 08:44:06]

This is done in a follow-up CL, already written.  I can merge them, but I prefer
not to.

+
   /**
    * Do two paths refer to the same object in the file system?
    * Links are not identical to their targets, and two links
+   * are not identical just because they point to identical targets.
+   * Links in intermediate directories in the paths are followed, though.
+   *
+   * Throws an error if one of the paths points to an object that does not
+   * exist.
+   * The target of a link can be compared by first getting it with Link.target.
+   */
+  static Future<bool> identical(String path1, String path2) =>
+      new Future<bool>(() => identicalSync(path1, path2));
+
+  /**
+   * Do two paths refer to the same object in the file system?
+   * Links are not identical to their targets, and two links
    * are not identical just because they point to identical targets.
    * Links in intermediate directories in the paths are followed, though.
    *
    * Throws an error if one of the paths points to an object that does not
    * exist.
    * The target of a link can be compared by first getting it with Link.target.
    */
   static bool identicalSync(String path1, String path2) {
     var result = _identical(path1, path2);
     _throwIfError(result, 'Error in FileSystemEntity.identical');
     return result;
   }
 
+  static Future<FileSystemEntityType> type(String path,
+                                           {bool followLinks: true})
+      => new Future<FileSystemEntityType>(

[Bill Hesse, 2013/05/02 14:02:42]

This function could be changed to its final, correct form using _getTypeAsync
already, as the ones below are.

[Bill Hesse, 2013/05/03 08:44:06]

Done in the second CL.

+          () => typeSync(path, followLinks: followLinks));
+
   static FileSystemEntityType typeSync(String path, {bool followLinks: true})
       => FileSystemEntityType._lookup(_getTypeSync(path, followLinks));
 
+  static Future<bool> isLink(String path) => _getTypeAsync(path, false)
+      .then((type) => (type == FileSystemEntityType.LINK._type));
+
+  static Future<bool> isFile(String path) => _getTypeAsync(path, true)
+      .then((type) => (type == FileSystemEntityType.FILE._type));
+
+  static Future<bool> isDirectory(String path) => _getTypeAsync(path, true)
+      .then((type) => (type == FileSystemEntityType.DIRECTORY._type));
+
   static bool isLinkSync(String path) =>
       (_getTypeSync(path, false) == FileSystemEntityType.LINK._type);
 
   static bool isFileSync(String path) =>
       (_getTypeSync(path, true) == FileSystemEntityType.FILE._type);
 
   static bool isDirectorySync(String path) =>
       (_getTypeSync(path, true) == FileSystemEntityType.DIRECTORY._type);
 
   static _throwIfError(Object result, String msg) {
     if (result is OSError) {
       throw new FileIOException(msg, result);
     } else if (result is ArgumentError) {
       throw result;
     }
   }
 }