io.vertx.core.file

## Interface FileSystem

-     public interface FileSystem

  Contains a broad set of operations for manipulating files on the file system.

  A (potential) blocking and non blocking version of each operation is provided.

  The non blocking versions take a handler which is called when the operation completes or an error occurs.

  The blocking versions are named `xxxBlocking` and return the results, or throw exceptions directly. In many cases, depending on the operating system and file system some of the potentially blocking operations can return quickly, which is why we provide them, but it's highly recommended that you test how long they take to return in your particular application before using them on an event loop.

  Please consult the documentation for more information on file system support.

  Author:
    Tim Fox

- - ### Method Summary

    All Methods Instance Methods Abstract Methods
    Modifier and Type | Method and Description
    --- | ---
    `Future<Void>` | `chmod(String path, String perms)` Like `chmod(String, String, Handler)` but returns a `Future` of the asynchronous result
    `FileSystem` | `chmod(String path, String perms, Handler<AsyncResult<Void>> handler)` Change the permissions on the file represented by `path` to `perms`, asynchronously.
    `FileSystem` | `chmodBlocking(String path, String perms)` Blocking version of `chmod(String, String, Handler)`
    `Future<Void>` | `chmodRecursive(String path, String perms, String dirPerms)` Like `chmodRecursive(String, String, String, Handler)` but returns a `Future` of the asynchronous result
    `FileSystem` | `chmodRecursive(String path, String perms, String dirPerms, Handler<AsyncResult<Void>> handler)` Change the permissions on the file represented by `path` to `perms`, asynchronously.
    `FileSystem` | `chmodRecursiveBlocking(String path, String perms, String dirPerms)` Blocking version of `chmodRecursive(String, String, String, Handler)`
    `Future<Void>` | `chown(String path, String user, String group)` Like `chown(String, String, String, Handler)` but returns a `Future` of the asynchronous result
    `FileSystem` | `chown(String path, String user, String group, Handler<AsyncResult<Void>> handler)` Change the ownership on the file represented by `path` to `user` and {code group}, asynchronously.
    `FileSystem` | `chownBlocking(String path, String user, String group)` Blocking version of `chown(String, String, String, Handler)`
    `Future<Void>` | `copy(String from, String to)` Like `copy(String, String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | `copy(String from, String to, CopyOptions options)` Like `copy(String, String, CopyOptions, Handler)` but returns a `Future` of the asynchronous result
    `FileSystem` | `copy(String from, String to, CopyOptions options, Handler<AsyncResult<Void>> handler)` Copy a file from the path `from` to path `to`, asynchronously.
    `FileSystem` | `copy(String from, String to, Handler<AsyncResult<Void>> handler)` Copy a file from the path `from` to path `to`, asynchronously.
    `FileSystem` | `copyBlocking(String from, String to)` Blocking version of `copy(String, String, Handler)`
    `Future<Void>` | `copyRecursive(String from, String to, boolean recursive)` Like `copyRecursive(String, String, boolean, Handler)` but returns a `Future` of the asynchronous result
    `FileSystem` | `copyRecursive(String from, String to, boolean recursive, Handler<AsyncResult<Void>> handler)` Copy a file from the path `from` to path `to`, asynchronously.
    `FileSystem` | `copyRecursiveBlocking(String from, String to, boolean recursive)` Blocking version of `copyRecursive(String, String, boolean, Handler)`
    `Future<Void>` | `createFile(String path)` Like `createFile(String, Handler)` but returns a `Future` of the asynchronous result
    `FileSystem` | `createFile(String path, Handler<AsyncResult<Void>> handler)` Creates an empty file with the specified `path`, asynchronously.
    `Future<Void>` | `createFile(String path, String perms)` Like `createFile(String, String, Handler)` but returns a `Future` of the asynchronous result
    `FileSystem` | `createFile(String path, String perms, Handler<AsyncResult<Void>> handler)` Creates an empty file with the specified `path` and permissions `perms`, asynchronously.
    `FileSystem` | `createFileBlocking(String path)` Blocking version of `createFile(String, Handler)`
    `FileSystem` | `createFileBlocking(String path, String perms)` Blocking version of `createFile(String, String, Handler)`
    `Future<String>` | `createTempDirectory(String prefix)` Like `createTempDirectory(String, Handler)` but returns a `Future` of the asynchronous result
    `FileSystem` | `createTempDirectory(String prefix, Handler<AsyncResult<String>> handler)` Creates a new directory in the default temporary-file directory, using the given prefix to generate its name, asynchronously.
    `Future<String>` | `createTempDirectory(String prefix, String perms)` Like `createTempDirectory(String, String, Handler)` but returns a `Future` of the asynchronous result
    `FileSystem` | `createTempDirectory(String prefix, String perms, Handler<AsyncResult<String>> handler)` Creates a new directory in the default temporary-file directory, using the given prefix to generate its name, asynchronously.
    `Future<String>` | `createTempDirectory(String dir, String prefix, String perms)` Like `createTempDirectory(String, String, String, Handler)` but returns a `Future` of the asynchronous result
    `FileSystem` | `createTempDirectory(String dir, String prefix, String perms, Handler<AsyncResult<String>> handler)` Creates a new directory in the directory provided by the path `path`, using the given prefix to generate its name, asynchronously.
    `String` | `createTempDirectoryBlocking(String prefix)` Blocking version of `createTempDirectory(String, Handler)`
    `String` | `createTempDirectoryBlocking(String prefix, String perms)` Blocking version of `createTempDirectory(String, String, Handler)`
    `String` | `createTempDirectoryBlocking(String dir, String prefix, String perms)` Blocking version of `createTempDirectory(String, String, String, Handler)`
    `Future<String>` | `createTempFile(String prefix, String suffix)` Like `createTempFile(String, String, Handler)` but returns a `Future` of the asynchronous result
    `FileSystem` | `createTempFile(String prefix, String suffix, Handler<AsyncResult<String>> handler)` Creates a new file in the default temporary-file directory, using the given prefix and suffix to generate its name, asynchronously.
    `Future<String>` | `createTempFile(String prefix, String suffix, String perms)` Like `createTempFile(String, String, String, Handler)` but returns a `Future` of the asynchronous result
    `FileSystem` | `createTempFile(String prefix, String suffix, String perms, Handler<AsyncResult<String>> handler)` Creates a new file in the directory provided by the path `dir`, using the given prefix and suffix to generate its name, asynchronously.
    `Future<String>` | `createTempFile(String dir, String prefix, String suffix, String perms)` Like `createTempFile(String, String, String, String, Handler)` but returns a `Future` of the asynchronous result
    `FileSystem` | `createTempFile(String dir, String prefix, String suffix, String perms, Handler<AsyncResult<String>> handler)` Creates a new file in the directory provided by the path `dir`, using the given prefix and suffix to generate its name, asynchronously.
    `String` | `createTempFileBlocking(String prefix, String suffix)` Blocking version of `createTempFile(String, String, Handler)`
    `String` | `createTempFileBlocking(String prefix, String suffix, String perms)` Blocking version of `createTempFile(String, String, String, Handler)`
    `String` | `createTempFileBlocking(String dir, String prefix, String suffix, String perms)` Blocking version of `createTempFile(String, String, String, String, Handler)`
    `Future<Void>` | `delete(String path)` Like `delete(String, Handler)` but returns a `Future` of the asynchronous result
    `FileSystem` | `delete(String path, Handler<AsyncResult<Void>> handler)` Deletes the file represented by the specified `path`, asynchronously.
    `FileSystem` | `deleteBlocking(String path)` Blocking version of `delete(String, Handler)`
    `Future<Void>` | `deleteRecursive(String path, boolean recursive)` Like `deleteRecursive(String, boolean, Handler)` but returns a `Future` of the asynchronous result
    `FileSystem` | `deleteRecursive(String path, boolean recursive, Handler<AsyncResult<Void>> handler)` Deletes the file represented by the specified `path`, asynchronously.
    `FileSystem` | `deleteRecursiveBlocking(String path, boolean recursive)` Blocking version of `deleteRecursive(String, boolean, Handler)`
    `Future<Boolean>` | `exists(String path)` Like `exists(String, Handler)` but returns a `Future` of the asynchronous result
    `FileSystem` | `exists(String path, Handler<AsyncResult<Boolean>> handler)` Determines whether the file as specified by the path `path` exists, asynchronously.
    `boolean` | `existsBlocking(String path)` Blocking version of `exists(String, Handler)`
    `Future<FileSystemProps>` | `fsProps(String path)` Like `fsProps(String, Handler)` but returns a `Future` of the asynchronous result
    `FileSystem` | `fsProps(String path, Handler<AsyncResult<FileSystemProps>> handler)` Returns properties of the file-system being used by the specified `path`, asynchronously.
    `FileSystemProps` | `fsPropsBlocking(String path)` Blocking version of `fsProps(String, Handler)`
    `Future<Void>` | `link(String link, String existing)` Like `link(String, String, Handler)` but returns a `Future` of the asynchronous result
    `FileSystem` | `link(String link, String existing, Handler<AsyncResult<Void>> handler)` Create a hard link on the file system from `link` to `existing`, asynchronously.
    `FileSystem` | `linkBlocking(String link, String existing)` Blocking version of `link(String, String, Handler)`
    `Future<FileProps>` | `lprops(String path)` Like `lprops(String, Handler)` but returns a `Future` of the asynchronous result
    `FileSystem` | `lprops(String path, Handler<AsyncResult<FileProps>> handler)` Obtain properties for the link represented by `path`, asynchronously.
    `FileProps` | `lpropsBlocking(String path)` Blocking version of `lprops(String, Handler)`
    `Future<Void>` | `mkdir(String path)` Like `mkdir(String, Handler)` but returns a `Future` of the asynchronous result
    `FileSystem` | `mkdir(String path, Handler<AsyncResult<Void>> handler)` Create the directory represented by `path`, asynchronously.
    `Future<Void>` | `mkdir(String path, String perms)` Like `mkdir(String, String, Handler)` but returns a `Future` of the asynchronous result
    `FileSystem` | `mkdir(String path, String perms, Handler<AsyncResult<Void>> handler)` Create the directory represented by `path`, asynchronously.
    `FileSystem` | `mkdirBlocking(String path)` Blocking version of `mkdir(String, Handler)`
    `FileSystem` | `mkdirBlocking(String path, String perms)` Blocking version of `mkdir(String, String, Handler)`
    `Future<Void>` | `mkdirs(String path)` Like `mkdirs(String, Handler)` but returns a `Future` of the asynchronous result
    `FileSystem` | `mkdirs(String path, Handler<AsyncResult<Void>> handler)` Create the directory represented by `path` and any non existent parents, asynchronously.
    `Future<Void>` | `mkdirs(String path, String perms)` Like `mkdirs(String, String, Handler)` but returns a `Future` of the asynchronous result
    `FileSystem` | `mkdirs(String path, String perms, Handler<AsyncResult<Void>> handler)` Create the directory represented by `path` and any non existent parents, asynchronously.
    `FileSystem` | `mkdirsBlocking(String path)` Blocking version of `mkdirs(String, Handler)`
    `FileSystem` | `mkdirsBlocking(String path, String perms)` Blocking version of `mkdirs(String, String, Handler)`
    `Future<Void>` | `move(String from, String to)` Like `move(String, String, Handler)` but returns a `Future` of the asynchronous result
    `Future<Void>` | `move(String from, String to, CopyOptions options)` Like `move(String, String, CopyOptions, Handler)` but returns a `Future` of the asynchronous result
    `FileSystem` | `move(String from, String to, CopyOptions options, Handler<AsyncResult<Void>> handler)` Move a file from the path `from` to path `to`, asynchronously.
    `FileSystem` | `move(String from, String to, Handler<AsyncResult<Void>> handler)` Move a file from the path `from` to path `to`, asynchronously.
    `FileSystem` | `moveBlocking(String from, String to)` Blocking version of `move(String, String, Handler)`
    `Future<AsyncFile>` | `open(String path, OpenOptions options)` Like `open(String, OpenOptions, Handler)` but returns a `Future` of the asynchronous result
    `FileSystem` | `open(String path, OpenOptions options, Handler<AsyncResult<AsyncFile>> handler)` Open the file represented by `path`, asynchronously.
    `AsyncFile` | `openBlocking(String path, OpenOptions options)` Blocking version of `open(String, io.vertx.core.file.OpenOptions, Handler)`
    `Future<FileProps>` | `props(String path)` Like `props(String, Handler)` but returns a `Future` of the asynchronous result
    `FileSystem` | `props(String path, Handler<AsyncResult<FileProps>> handler)` Obtain properties for the file represented by `path`, asynchronously.
    `FileProps` | `propsBlocking(String path)` Blocking version of `props(String, Handler)`
    `Future<List<String>>` | `readDir(String path)` Like `readDir(String, Handler)` but returns a `Future` of the asynchronous result
    `FileSystem` | `readDir(String path, Handler<AsyncResult<List<String>>> handler)` Read the contents of the directory specified by `path`, asynchronously.
    `Future<List<String>>` | `readDir(String path, String filter)` Like `readDir(String, Handler)` but returns a `Future` of the asynchronous result
    `FileSystem` | `readDir(String path, String filter, Handler<AsyncResult<List<String>>> handler)` Read the contents of the directory specified by `path`, asynchronously.
    `List<String>` | `readDirBlocking(String path)` Blocking version of `readDir(String, Handler)`
    `List<String>` | `readDirBlocking(String path, String filter)` Blocking version of `readDir(String, String, Handler)`
    `Future<Buffer>` | `readFile(String path)` Like `readFile(String, Handler)` but returns a `Future` of the asynchronous result
    `FileSystem` | `readFile(String path, Handler<AsyncResult<Buffer>> handler)` Reads the entire file as represented by the path `path` as a `Buffer`, asynchronously.
    `Buffer` | `readFileBlocking(String path)` Blocking version of `readFile(String, Handler)`
    `Future<String>` | `readSymlink(String link)` Like `readSymlink(String, Handler)` but returns a `Future` of the asynchronous result
    `FileSystem` | `readSymlink(String link, Handler<AsyncResult<String>> handler)` Returns the path representing the file that the symbolic link specified by `link` points to, asynchronously.
    `String` | `readSymlinkBlocking(String link)` Blocking version of `readSymlink(String, Handler)`
    `Future<Void>` | `symlink(String link, String existing)` Like `symlink(String, String, Handler)` but returns a `Future` of the asynchronous result
    `FileSystem` | `symlink(String link, String existing, Handler<AsyncResult<Void>> handler)` Create a symbolic link on the file system from `link` to `existing`, asynchronously.
    `FileSystem` | `symlinkBlocking(String link, String existing)` Blocking version of `link(String, String, Handler)`
    `Future<Void>` | `truncate(String path, long len)` Like `truncate(String, long, Handler)` but returns a `Future` of the asynchronous result
    `FileSystem` | `truncate(String path, long len, Handler<AsyncResult<Void>> handler)` Truncate the file represented by `path` to length `len` in bytes, asynchronously.
    `FileSystem` | `truncateBlocking(String path, long len)` Blocking version of `truncate(String, long, Handler)`
    `Future<Void>` | `unlink(String link)` Like `unlink(String, Handler)` but returns a `Future` of the asynchronous result
    `FileSystem` | `unlink(String link, Handler<AsyncResult<Void>> handler)` Unlinks the link on the file system represented by the path `link`, asynchronously.
    `FileSystem` | `unlinkBlocking(String link)` Blocking version of `unlink(String, Handler)`
    `Future<Void>` | `writeFile(String path, Buffer data)` Like `writeFile(String, Buffer, Handler)` but returns a `Future` of the asynchronous result
    `FileSystem` | `writeFile(String path, Buffer data, Handler<AsyncResult<Void>> handler)` Creates the file, and writes the specified `Buffer data` to the file represented by the path `path`, asynchronously.
    `FileSystem` | `writeFileBlocking(String path, Buffer data)` Blocking version of `writeFile(String, Buffer, Handler)`

- - ### Method Detail

    - #### copy

          FileSystem copy(String from,
                          String to,
                          Handler<AsyncResult<Void>> handler)

      Copy a file from the path `from` to path `to`, asynchronously.

      The copy will fail if the destination already exists.

      Parameters:
        `from` - the path to copy from
        `to` - the path to copy to
        `handler` - the handler that will be called on completion
      Returns:
        a reference to this, so the API can be used fluently

    - #### copy

          Future<Void> copy(String from,
                            String to)

      Like `copy(String, String, Handler)` but returns a `Future` of the asynchronous result

    - #### copy

          FileSystem copy(String from,
                          String to,
                          CopyOptions options,
                          Handler<AsyncResult<Void>> handler)

      Copy a file from the path `from` to path `to`, asynchronously.
      Parameters:
        `from` - the path to copy from
        `to` - the path to copy to
        `options` - options describing how the file should be copied
        `handler` - the handler that will be called on completion
      Returns:
        a reference to this, so the API can be used fluently

    - #### copy

          Future<Void> copy(String from,
                            String to,
                            CopyOptions options)

      Like `copy(String, String, CopyOptions, Handler)` but returns a `Future` of the asynchronous result

    - #### copyBlocking

          FileSystem copyBlocking(String from,
                                  String to)

      Blocking version of `copy(String, String, Handler)`

    - #### copyRecursive

          FileSystem copyRecursive(String from,
                                   String to,
                                   boolean recursive,
                                   Handler<AsyncResult<Void>> handler)

      Copy a file from the path `from` to path `to`, asynchronously.

      If `recursive` is `true` and `from` represents a directory, then the directory and its contents will be copied recursively to the destination `to`.

      The copy will fail if the destination if the destination already exists.

      Parameters:
        `from` - the path to copy from
        `to` - the path to copy to
        `recursive` -
        `handler` - the handler that will be called on completion
      Returns:
        a reference to this, so the API can be used fluently

    - #### copyRecursive

          Future<Void> copyRecursive(String from,
                                     String to,
                                     boolean recursive)

      Like `copyRecursive(String, String, boolean, Handler)` but returns a `Future` of the asynchronous result

    - #### copyRecursiveBlocking

          FileSystem copyRecursiveBlocking(String from,
                                           String to,
                                           boolean recursive)

      Blocking version of `copyRecursive(String, String, boolean, Handler)`

    - #### move

          FileSystem move(String from,
                          String to,
                          Handler<AsyncResult<Void>> handler)

      Move a file from the path `from` to path `to`, asynchronously.

      The move will fail if the destination already exists.

      Parameters:
        `from` - the path to copy from
        `to` - the path to copy to
        `handler` - the handler that will be called on completion
      Returns:
        a reference to this, so the API can be used fluently

    - #### move

          Future<Void> move(String from,
                            String to)

      Like `move(String, String, Handler)` but returns a `Future` of the asynchronous result

    - #### move

          FileSystem move(String from,
                          String to,
                          CopyOptions options,
                          Handler<AsyncResult<Void>> handler)

      Move a file from the path `from` to path `to`, asynchronously.
      Parameters:
        `from` - the path to copy from
        `to` - the path to copy to
        `options` - options describing how the file should be copied
        `handler` - the handler that will be called on completion
      Returns:
        a reference to this, so the API can be used fluently

    - #### move

          Future<Void> move(String from,
                            String to,
                            CopyOptions options)

      Like `move(String, String, CopyOptions, Handler)` but returns a `Future` of the asynchronous result

    - #### moveBlocking

          FileSystem moveBlocking(String from,
                                  String to)

      Blocking version of `move(String, String, Handler)`

    - #### truncate

          FileSystem truncate(String path,
                              long len,
                              Handler<AsyncResult<Void>> handler)

      Truncate the file represented by `path` to length `len` in bytes, asynchronously.

      The operation will fail if the file does not exist or `len` is less than `zero`.

      Parameters:
        `path` - the path to the file
        `len` - the length to truncate it to
        `handler` - the handler that will be called on completion
      Returns:
        a reference to this, so the API can be used fluently

    - #### truncate

          Future<Void> truncate(String path,
                                long len)

      Like `truncate(String, long, Handler)` but returns a `Future` of the asynchronous result

    - #### truncateBlocking

          FileSystem truncateBlocking(String path,
                                      long len)

      Blocking version of `truncate(String, long, Handler)`

    - #### chmod

          FileSystem chmod(String path,
                           String perms,
                           Handler<AsyncResult<Void>> handler)

      Change the permissions on the file represented by `path` to `perms`, asynchronously.

      The permission String takes the form rwxr-x--- as specified here.

      Parameters:
        `path` - the path to the file
        `perms` - the permissions string
        `handler` - the handler that will be called on completion
      Returns:
        a reference to this, so the API can be used fluently

    - #### chmod

          Future<Void> chmod(String path,
                             String perms)

      Like `chmod(String, String, Handler)` but returns a `Future` of the asynchronous result

    - #### chmodBlocking

          FileSystem chmodBlocking(String path,
                                   String perms)

      Blocking version of `chmod(String, String, Handler)`

    - #### chmodRecursive

          FileSystem chmodRecursive(String path,
                                    String perms,
                                    String dirPerms,
                                    Handler<AsyncResult<Void>> handler)

      Change the permissions on the file represented by `path` to `perms`, asynchronously.

      The permission String takes the form rwxr-x--- as specified in {here}.

      If the file is directory then all contents will also have their permissions changed recursively. Any directory permissions will be set to `dirPerms`, whilst any normal file permissions will be set to `perms`.

      Parameters:
        `path` - the path to the file
        `perms` - the permissions string
        `dirPerms` - the directory permissions
        `handler` - the handler that will be called on completion
      Returns:
        a reference to this, so the API can be used fluently

    - #### chmodRecursive

          Future<Void> chmodRecursive(String path,
                                      String perms,
                                      String dirPerms)

      Like `chmodRecursive(String, String, String, Handler)` but returns a `Future` of the asynchronous result

    - #### chmodRecursiveBlocking

          FileSystem chmodRecursiveBlocking(String path,
                                            String perms,
                                            String dirPerms)

      Blocking version of `chmodRecursive(String, String, String, Handler)`

    - #### chown

          FileSystem chown(String path,
                           String user,
                           String group,
                           Handler<AsyncResult<Void>> handler)

      Change the ownership on the file represented by `path` to `user` and {code group}, asynchronously.
      Parameters:
        `path` - the path to the file
        `user` - the user name, `null` will not change the user name
        `group` - the user group, `null` will not change the user group name
        `handler` - the handler that will be called on completion
      Returns:
        a reference to this, so the API can be used fluently

    - #### chown

          Future<Void> chown(String path,
                             String user,
                             String group)

      Like `chown(String, String, String, Handler)` but returns a `Future` of the asynchronous result

    - #### chownBlocking

          FileSystem chownBlocking(String path,
                                   String user,
                                   String group)

      Blocking version of `chown(String, String, String, Handler)`

    - #### props

          FileSystem props(String path,
                           Handler<AsyncResult<FileProps>> handler)

      Obtain properties for the file represented by `path`, asynchronously.

      If the file is a link, the link will be followed.

      Parameters:
        `path` - the path to the file
        `handler` - the handler that will be called on completion
      Returns:
        a reference to this, so the API can be used fluently

    - #### props

          Future<FileProps> props(String path)

      Like `props(String, Handler)` but returns a `Future` of the asynchronous result

    - #### propsBlocking

          FileProps propsBlocking(String path)

      Blocking version of `props(String, Handler)`

    - #### lprops

          FileSystem lprops(String path,
                            Handler<AsyncResult<FileProps>> handler)

      Obtain properties for the link represented by `path`, asynchronously.

      The link will not be followed.

      Parameters:
        `path` - the path to the file
        `handler` - the handler that will be called on completion
      Returns:
        a reference to this, so the API can be used fluently

    - #### lprops

          Future<FileProps> lprops(String path)

      Like `lprops(String, Handler)` but returns a `Future` of the asynchronous result

    - #### lpropsBlocking

          FileProps lpropsBlocking(String path)

      Blocking version of `lprops(String, Handler)`

    - #### link

          FileSystem link(String link,
                          String existing,
                          Handler<AsyncResult<Void>> handler)

      Create a hard link on the file system from `link` to `existing`, asynchronously.
      Parameters:
        `link` - the link
        `existing` - the link destination
        `handler` - the handler that will be called on completion
      Returns:
        a reference to this, so the API can be used fluently

    - #### link

          Future<Void> link(String link,
                            String existing)

      Like `link(String, String, Handler)` but returns a `Future` of the asynchronous result

    - #### linkBlocking

          FileSystem linkBlocking(String link,
                                  String existing)

      Blocking version of `link(String, String, Handler)`

    - #### symlink

          FileSystem symlink(String link,
                             String existing,
                             Handler<AsyncResult<Void>> handler)

      Create a symbolic link on the file system from `link` to `existing`, asynchronously.
      Parameters:
        `link` - the link
        `existing` - the link destination
        `handler` - the handler that will be called on completion
      Returns:
        a reference to this, so the API can be used fluently

    - #### symlink

          Future<Void> symlink(String link,
                               String existing)

      Like `symlink(String, String, Handler)` but returns a `Future` of the asynchronous result

    - #### symlinkBlocking

          FileSystem symlinkBlocking(String link,
                                     String existing)

      Blocking version of `link(String, String, Handler)`

    - #### unlink

          FileSystem unlink(String link,
                            Handler<AsyncResult<Void>> handler)

      Unlinks the link on the file system represented by the path `link`, asynchronously.
      Parameters:
        `link` - the link
        `handler` - the handler that will be called on completion
      Returns:
        a reference to this, so the API can be used fluently

    - #### unlink

          Future<Void> unlink(String link)

      Like `unlink(String, Handler)` but returns a `Future` of the asynchronous result

    - #### unlinkBlocking

          FileSystem unlinkBlocking(String link)

      Blocking version of `unlink(String, Handler)`

    - #### readSymlink

          FileSystem readSymlink(String link,
                                 Handler<AsyncResult<String>> handler)

      Returns the path representing the file that the symbolic link specified by `link` points to, asynchronously.
      Parameters:
        `link` - the link
        `handler` - the handler that will be called on completion
      Returns:
        a reference to this, so the API can be used fluently

    - #### readSymlink

          Future<String> readSymlink(String link)

      Like `readSymlink(String, Handler)` but returns a `Future` of the asynchronous result

    - #### readSymlinkBlocking

          String readSymlinkBlocking(String link)

      Blocking version of `readSymlink(String, Handler)`

    - #### delete

          FileSystem delete(String path,
                            Handler<AsyncResult<Void>> handler)

      Deletes the file represented by the specified `path`, asynchronously.
      Parameters:
        `path` - path to the file
        `handler` - the handler that will be called on completion
      Returns:
        a reference to this, so the API can be used fluently

    - #### delete

          Future<Void> delete(String path)

      Like `delete(String, Handler)` but returns a `Future` of the asynchronous result

    - #### deleteBlocking

          FileSystem deleteBlocking(String path)

      Blocking version of `delete(String, Handler)`

    - #### deleteRecursive

          FileSystem deleteRecursive(String path,
                                     boolean recursive,
                                     Handler<AsyncResult<Void>> handler)

      Deletes the file represented by the specified `path`, asynchronously.

      If the path represents a directory and `recursive = true` then the directory and its contents will be deleted recursively.

      Parameters:
        `path` - path to the file
        `recursive` - delete recursively?
        `handler` - the handler that will be called on completion
      Returns:
        a reference to this, so the API can be used fluently

    - #### deleteRecursive

          Future<Void> deleteRecursive(String path,
                                       boolean recursive)

      Like `deleteRecursive(String, boolean, Handler)` but returns a `Future` of the asynchronous result

    - #### deleteRecursiveBlocking

          FileSystem deleteRecursiveBlocking(String path,
                                             boolean recursive)

      Blocking version of `deleteRecursive(String, boolean, Handler)`

    - #### mkdir

          FileSystem mkdir(String path,
                           Handler<AsyncResult<Void>> handler)

      Create the directory represented by `path`, asynchronously.

      The operation will fail if the directory already exists.

      Parameters:
        `path` - path to the file
        `handler` - the handler that will be called on completion
      Returns:
        a reference to this, so the API can be used fluently

    - #### mkdir

          Future<Void> mkdir(String path)

      Like `mkdir(String, Handler)` but returns a `Future` of the asynchronous result

    - #### mkdirBlocking

          FileSystem mkdirBlocking(String path)

      Blocking version of `mkdir(String, Handler)`

    - #### mkdir

          FileSystem mkdir(String path,
                           String perms,
                           Handler<AsyncResult<Void>> handler)

      Create the directory represented by `path`, asynchronously.

      The new directory will be created with permissions as specified by `perms`.

      The permission String takes the form rwxr-x--- as specified in here.

      The operation will fail if the directory already exists.

      Parameters:
        `path` - path to the file
        `perms` - the permissions string
        `handler` - the handler that will be called on completion
      Returns:
        a reference to this, so the API can be used fluently

    - #### mkdir

          Future<Void> mkdir(String path,
                             String perms)

      Like `mkdir(String, String, Handler)` but returns a `Future` of the asynchronous result

    - #### mkdirBlocking

          FileSystem mkdirBlocking(String path,
                                   String perms)

      Blocking version of `mkdir(String, String, Handler)`

    - #### mkdirs

          FileSystem mkdirs(String path,
                            Handler<AsyncResult<Void>> handler)

      Create the directory represented by `path` and any non existent parents, asynchronously.

      The operation will fail if the `path` already exists but is not a directory.

      Parameters:
        `path` - path to the file
        `handler` - the handler that will be called on completion
      Returns:
        a reference to this, so the API can be used fluently

    - #### mkdirs

          Future<Void> mkdirs(String path)

      Like `mkdirs(String, Handler)` but returns a `Future` of the asynchronous result

    - #### mkdirsBlocking

          FileSystem mkdirsBlocking(String path)

      Blocking version of `mkdirs(String, Handler)`

    - #### mkdirs

          FileSystem mkdirs(String path,
                            String perms,
                            Handler<AsyncResult<Void>> handler)

      Create the directory represented by `path` and any non existent parents, asynchronously.

      The new directory will be created with permissions as specified by `perms`.

      The permission String takes the form rwxr-x--- as specified in here.

      The operation will fail if the `path` already exists but is not a directory.

      Parameters:
        `path` - path to the file
        `perms` - the permissions string
        `handler` - the handler that will be called on completion
      Returns:
        a reference to this, so the API can be used fluently

    - #### mkdirs

          Future<Void> mkdirs(String path,
                              String perms)

      Like `mkdirs(String, String, Handler)` but returns a `Future` of the asynchronous result

    - #### mkdirsBlocking

          FileSystem mkdirsBlocking(String path,
                                    String perms)

      Blocking version of `mkdirs(String, String, Handler)`

    - #### readDir

          FileSystem readDir(String path,
                             Handler<AsyncResult<List<String>>> handler)

      Read the contents of the directory specified by `path`, asynchronously.

      The result is an array of String representing the paths of the files inside the directory.

      Parameters:
        `path` - path to the file
        `handler` - the handler that will be called on completion
      Returns:
        a reference to this, so the API can be used fluently

    - #### readDir

          Future<List<String>> readDir(String path)

      Like `readDir(String, Handler)` but returns a `Future` of the asynchronous result

    - #### readDirBlocking

          List<String> readDirBlocking(String path)

      Blocking version of `readDir(String, Handler)`

    - #### readDir

          FileSystem readDir(String path,
                             String filter,
                             Handler<AsyncResult<List<String>>> handler)

      Read the contents of the directory specified by `path`, asynchronously.

      The parameter `filter` is a regular expression. If `filter` is specified then only the paths that match @{filter}will be returned.

      The result is an array of String representing the paths of the files inside the directory.

      Parameters:
        `path` - path to the directory
        `filter` - the filter expression
        `handler` - the handler that will be called on completion
      Returns:
        a reference to this, so the API can be used fluently

    - #### readDir

          Future<List<String>> readDir(String path,
                                       String filter)

      Like `readDir(String, Handler)` but returns a `Future` of the asynchronous result

    - #### readDirBlocking

          List<String> readDirBlocking(String path,
                                       String filter)

      Blocking version of `readDir(String, String, Handler)`

    - #### readFile

          FileSystem readFile(String path,
                              Handler<AsyncResult<Buffer>> handler)

      Reads the entire file as represented by the path `path` as a `Buffer`, asynchronously.

      Do not use this method to read very large files or you risk running out of available RAM.

      Parameters:
        `path` - path to the file
        `handler` - the handler that will be called on completion
      Returns:
        a reference to this, so the API can be used fluently

    - #### readFile

          Future<Buffer> readFile(String path)

      Like `readFile(String, Handler)` but returns a `Future` of the asynchronous result

    - #### readFileBlocking

          Buffer readFileBlocking(String path)

      Blocking version of `readFile(String, Handler)`

    - #### writeFile

          FileSystem writeFile(String path,
                               Buffer data,
                               Handler<AsyncResult<Void>> handler)

      Creates the file, and writes the specified `Buffer data` to the file represented by the path `path`, asynchronously.
      Parameters:
        `path` - path to the file
        `handler` - the handler that will be called on completion
      Returns:
        a reference to this, so the API can be used fluently

    - #### writeFile

          Future<Void> writeFile(String path,
                                 Buffer data)

      Like `writeFile(String, Buffer, Handler)` but returns a `Future` of the asynchronous result

    - #### writeFileBlocking

          FileSystem writeFileBlocking(String path,
                                       Buffer data)

      Blocking version of `writeFile(String, Buffer, Handler)`

    - #### open

          FileSystem open(String path,
                          OpenOptions options,
                          Handler<AsyncResult<AsyncFile>> handler)

      Open the file represented by `path`, asynchronously.

      The file is opened for both reading and writing. If the file does not already exist it will be created.

      Parameters:
        `path` - path to the file
        `options` - options describing how the file should be opened
      Returns:
        a reference to this, so the API can be used fluently

    - #### open

          Future<AsyncFile> open(String path,
                                 OpenOptions options)

      Like `open(String, OpenOptions, Handler)` but returns a `Future` of the asynchronous result

    - #### openBlocking

          AsyncFile openBlocking(String path,
                                 OpenOptions options)

      Blocking version of `open(String, io.vertx.core.file.OpenOptions, Handler)`

    - #### createFile

          FileSystem createFile(String path,
                                Handler<AsyncResult<Void>> handler)

      Creates an empty file with the specified `path`, asynchronously.
      Parameters:
        `path` - path to the file
        `handler` - the handler that will be called on completion
      Returns:
        a reference to this, so the API can be used fluently

    - #### createFile

          Future<Void> createFile(String path)

      Like `createFile(String, Handler)` but returns a `Future` of the asynchronous result

    - #### createFileBlocking

          FileSystem createFileBlocking(String path)

      Blocking version of `createFile(String, Handler)`

    - #### createFile

          FileSystem createFile(String path,
                                String perms,
                                Handler<AsyncResult<Void>> handler)

      Creates an empty file with the specified `path` and permissions `perms`, asynchronously.
      Parameters:
        `path` - path to the file
        `perms` - the permissions string
        `handler` - the handler that will be called on completion
      Returns:
        a reference to this, so the API can be used fluently

    - #### createFile

          Future<Void> createFile(String path,
                                  String perms)

      Like `createFile(String, String, Handler)` but returns a `Future` of the asynchronous result

    - #### createFileBlocking

          FileSystem createFileBlocking(String path,
                                        String perms)

      Blocking version of `createFile(String, String, Handler)`

    - #### exists

          FileSystem exists(String path,
                            Handler<AsyncResult<Boolean>> handler)

      Determines whether the file as specified by the path `path` exists, asynchronously.
      Parameters:
        `path` - path to the file
        `handler` - the handler that will be called on completion
      Returns:
        a reference to this, so the API can be used fluently

    - #### exists

          Future<Boolean> exists(String path)

      Like `exists(String, Handler)` but returns a `Future` of the asynchronous result

    - #### existsBlocking

          boolean existsBlocking(String path)

      Blocking version of `exists(String, Handler)`

    - #### fsProps

          FileSystem fsProps(String path,
                             Handler<AsyncResult<FileSystemProps>> handler)

      Returns properties of the file-system being used by the specified `path`, asynchronously.
      Parameters:
        `path` - path to anywhere on the filesystem
        `handler` - the handler that will be called on completion
      Returns:
        a reference to this, so the API can be used fluently

    - #### fsProps

          Future<FileSystemProps> fsProps(String path)

      Like `fsProps(String, Handler)` but returns a `Future` of the asynchronous result

    - #### fsPropsBlocking

          FileSystemProps fsPropsBlocking(String path)

      Blocking version of `fsProps(String, Handler)`

    - #### createTempDirectory

          FileSystem createTempDirectory(String prefix,
                                         Handler<AsyncResult<String>> handler)

      Creates a new directory in the default temporary-file directory, using the given prefix to generate its name, asynchronously.

      As with the `File.createTempFile` methods, this method is only part of a temporary-file facility.A `shutdown-hook`, or the `File.deleteOnExit()` mechanism may be used to delete the directory automatically.

      Parameters:
        `prefix` - the prefix string to be used in generating the directory's name; may be `null`
        `handler` - the handler that will be called on completion
      Returns:
        a reference to this, so the API can be used fluently

    - #### createTempDirectory

          Future<String> createTempDirectory(String prefix)

      Like `createTempDirectory(String, Handler)` but returns a `Future` of the asynchronous result

    - #### createTempDirectoryBlocking

          String createTempDirectoryBlocking(String prefix)

      Blocking version of `createTempDirectory(String, Handler)`

    - #### createTempDirectory

          FileSystem createTempDirectory(String prefix,
                                         String perms,
                                         Handler<AsyncResult<String>> handler)

      Creates a new directory in the default temporary-file directory, using the given prefix to generate its name, asynchronously.

      The new directory will be created with permissions as specified by `perms`.

      The permission String takes the form rwxr-x--- as specified in here.

      As with the `File.createTempFile` methods, this method is only part of a temporary-file facility.A `shutdown-hook`, or the `File.deleteOnExit()` mechanism may be used to delete the directory automatically.

      Parameters:
        `prefix` - the prefix string to be used in generating the directory's name; may be `null`
        `perms` - the permissions string
        `handler` - the handler that will be called on completion
      Returns:
        a reference to this, so the API can be used fluently

    - #### createTempDirectory

          Future<String> createTempDirectory(String prefix,
                                             String perms)

      Like `createTempDirectory(String, String, Handler)` but returns a `Future` of the asynchronous result

    - #### createTempDirectoryBlocking

          String createTempDirectoryBlocking(String prefix,
                                             String perms)

      Blocking version of `createTempDirectory(String, String, Handler)`

    - #### createTempDirectory

          FileSystem createTempDirectory(String dir,
                                         String prefix,
                                         String perms,
                                         Handler<AsyncResult<String>> handler)

      Creates a new directory in the directory provided by the path `path`, using the given prefix to generate its name, asynchronously.

      The new directory will be created with permissions as specified by `perms`.

      The permission String takes the form rwxr-x--- as specified in here.

      As with the `File.createTempFile` methods, this method is only part of a temporary-file facility.A `shutdown-hook`, or the `File.deleteOnExit()` mechanism may be used to delete the directory automatically.

      Parameters:
        `dir` - the path to directory in which to create the directory
        `prefix` - the prefix string to be used in generating the directory's name; may be `null`
        `perms` - the permissions string
        `handler` - the handler that will be called on completion
      Returns:
        a reference to this, so the API can be used fluently

    - #### createTempDirectory

          Future<String> createTempDirectory(String dir,
                                             String prefix,
                                             String perms)

      Like `createTempDirectory(String, String, String, Handler)` but returns a `Future` of the asynchronous result

    - #### createTempDirectoryBlocking

          String createTempDirectoryBlocking(String dir,
                                             String prefix,
                                             String perms)

      Blocking version of `createTempDirectory(String, String, String, Handler)`

    - #### createTempFile

          FileSystem createTempFile(String prefix,
                                    String suffix,
                                    Handler<AsyncResult<String>> handler)

      Creates a new file in the default temporary-file directory, using the given prefix and suffix to generate its name, asynchronously.

      As with the `File.createTempFile` methods, this method is only part of a temporary-file facility.A `shutdown-hook`, or the `File.deleteOnExit()` mechanism may be used to delete the directory automatically.

      Parameters:
        `prefix` - the prefix string to be used in generating the directory's name; may be `null`
        `suffix` - the suffix string to be used in generating the file's name; may be `null`, in which case "`.tmp`" is used
        `handler` - the handler that will be called on completion
      Returns:
        a reference to this, so the API can be used fluently

    - #### createTempFile

          Future<String> createTempFile(String prefix,
                                        String suffix)

      Like `createTempFile(String, String, Handler)` but returns a `Future` of the asynchronous result

    - #### createTempFileBlocking

          String createTempFileBlocking(String prefix,
                                        String suffix)

      Blocking version of `createTempFile(String, String, Handler)`

    - #### createTempFile

          FileSystem createTempFile(String prefix,
                                    String suffix,
                                    String perms,
                                    Handler<AsyncResult<String>> handler)

      Creates a new file in the directory provided by the path `dir`, using the given prefix and suffix to generate its name, asynchronously.

      As with the `File.createTempFile` methods, this method is only part of a temporary-file facility.A `shutdown-hook`, or the `File.deleteOnExit()` mechanism may be used to delete the directory automatically.

      Parameters:
        `prefix` - the prefix string to be used in generating the directory's name; may be `null`
        `suffix` - the suffix string to be used in generating the file's name; may be `null`, in which case "`.tmp`" is used
        `handler` - the handler that will be called on completion
      Returns:
        a reference to this, so the API can be used fluently

    - #### createTempFile

          Future<String> createTempFile(String prefix,
                                        String suffix,
                                        String perms)

      Like `createTempFile(String, String, String, Handler)` but returns a `Future` of the asynchronous result

    - #### createTempFileBlocking

          String createTempFileBlocking(String prefix,
                                        String suffix,
                                        String perms)

      Blocking version of `createTempFile(String, String, String, Handler)`

    - #### createTempFile

          FileSystem createTempFile(String dir,
                                    String prefix,
                                    String suffix,
                                    String perms,
                                    Handler<AsyncResult<String>> handler)

      Creates a new file in the directory provided by the path `dir`, using the given prefix and suffix to generate its name, asynchronously.

      The new directory will be created with permissions as specified by `perms`.

      The permission String takes the form rwxr-x--- as specified in here.

      As with the `File.createTempFile` methods, this method is only part of a temporary-file facility.A `shutdown-hook`, or the `File.deleteOnExit()` mechanism may be used to delete the directory automatically.

      Parameters:
        `dir` - the path to directory in which to create the directory
        `prefix` - the prefix string to be used in generating the directory's name; may be `null`
        `suffix` - the suffix string to be used in generating the file's name; may be `null`, in which case "`.tmp`" is used
        `perms` - the permissions string
        `handler` - the handler that will be called on completion
      Returns:
        a reference to this, so the API can be used fluently

    - #### createTempFile

          Future<String> createTempFile(String dir,
                                        String prefix,
                                        String suffix,
                                        String perms)

      Like `createTempFile(String, String, String, String, Handler)` but returns a `Future` of the asynchronous result

    - #### createTempFileBlocking

          String createTempFileBlocking(String dir,
                                        String prefix,
                                        String suffix,
                                        String perms)

      Blocking version of `createTempFile(String, String, String, String, Handler)`

Copyright © 2022 Eclipse. All rights reserved.