[dart:io] Adds functions to set file access and modification time

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 230 matching lines @@
   external static _exists(String path);
 
   bool existsSync() {
     var result = _exists(path);
     throwIfError(result, "Cannot check existence of file", path);
     return result;
   }
 
   File get absolute => new File(_absolutePath);
 
-  Future<FileStat> stat() => FileStat.stat(path);
-
-  FileStat statSync() => FileStat.statSync(path);
-
   Future<File> create({bool recursive: false}) {
     var result = recursive ? parent.create(recursive: true)
                            : new Future.value(null);
     return result
       .then((_) => _IOService._dispatch(_FILE_CREATE, [path]))
       .then((response) {
         if (_isErrorResponse(response)) {
           throw _exceptionFromResponse(response, "Cannot create file", path);
         }
         return this;
@@ skipping 108 matching lines @@
 
 
   external static _lengthFromPath(String path);
 
   int lengthSync() {
     var result = _lengthFromPath(path);
     throwIfError(result, "Cannot retrieve length of file", path);
     return result;
   }
 
+  Future<DateTime> lastAccessed() {
+    return _IOService._dispatch(_FILE_LAST_ACCESSED, [path]).then((response) {
+      if (_isErrorResponse(response)) {
+        throw _exceptionFromResponse(response,
+                                     "Cannot retrieve access time",
+                                     path);
+      }
+      return new DateTime.fromMillisecondsSinceEpoch(response);
+    });
+  }
+
+  external static _lastAccessed(String path);
+
+  DateTime lastAccessedSync() {
+    var ms = _lastAccessed(path);
+    throwIfError(ms, "Cannot retrieve access time", path);
+    return new DateTime.fromMillisecondsSinceEpoch(ms);
+  }
+
+  Future setLastAccessed(DateTime time) {
+    int millis = time.millisecondsSinceEpoch;
+    return _IOService._dispatch(_FILE_SET_LAST_ACCESSED, [path, millis])
+                     .then((response) {
+      if (_isErrorResponse(response)) {
+        throw _exceptionFromResponse(response,
+                                     "Cannot set access time",
+                                     path);
+      }
+      return null;
+    });
+  }
+
+  external static _setLastAccessed(String path, int millis);
+
+  void setLastAccessedSync(DateTime time) {
+    int millis = time.millisecondsSinceEpoch;
+    var result = _setLastAccessed(path, millis);
+    if (result is OSError) {
+      throw new FileSystemException("Failed to set file access time",
+          path, result);
+    }
+  }
+
   Future<DateTime> lastModified() {
     return _IOService._dispatch(_FILE_LAST_MODIFIED, [path]).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
                                      "Cannot retrieve modification time",
                                      path);
       }
       return new DateTime.fromMillisecondsSinceEpoch(response);
     });
   }
 
   external static _lastModified(String path);
 
   DateTime lastModifiedSync() {
     var ms = _lastModified(path);
     throwIfError(ms, "Cannot retrieve modification time", path);
     return new DateTime.fromMillisecondsSinceEpoch(ms);
   }
 
+  Future setLastModified(DateTime time) {
+    int millis = time.millisecondsSinceEpoch;
+    return _IOService._dispatch(_FILE_SET_LAST_MODIFIED, [path, millis])
+                     .then((response) {
+      if (_isErrorResponse(response)) {
+        throw _exceptionFromResponse(response,
+                                     "Cannot set modification time",
+                                     path);
+      }
+      return null;
+    });
+  }
+
+  external static _setLastModified(String path, int millis);
+
+  void setLastModifiedSync(DateTime time) {
+    int millis = time.millisecondsSinceEpoch;
+    var result = _setLastModified(path, millis);
+    if (result is OSError) {
+      throw new FileSystemException("Failed to set file modification time",
+          path, result);
+    }
+  }
+
   external static _open(String path, int mode);
 
   RandomAccessFile openSync({FileMode mode: FileMode.READ}) {
     if (mode != FileMode.READ &&
         mode != FileMode.WRITE &&
         mode != FileMode.APPEND &&
         mode != FileMode.WRITE_ONLY &&
         mode != FileMode.WRITE_ONLY_APPEND) {
       throw new ArgumentError('Invalid file mode for this operation');
     }
@@ skipping 616 matching lines @@
   void _checkAvailable() {
     if (_asyncDispatched) {
       throw new FileSystemException("An async operation is currently pending",
                                     path);
     }
     if (closed) {
       throw new FileSystemException("File closed", path);
     }
   }
 }