io.vertx.rxjava.core.file

## Class FileSystem

- java.lang.Object
- - io.vertx.rxjava.core.file.FileSystem

-     public class FileSystem
      extends Object

  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.

  NOTE: This class has been automatically generated from the `original` non RX-ified interface using Vert.x codegen.

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static TypeArg<FileSystem>` | `__TYPE_ARG`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `FileSystem(FileSystem delegate)`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
    Modifier and Type | Method and Description
    --- | ---
    `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)`
    `rx.Observable<Void>` | `chmodObservable(String path, String perms)` Deprecated. use `rxChmod(java.lang.String, java.lang.String)` instead
    `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(java.lang.String, java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
    `rx.Observable<Void>` | `chmodRecursiveObservable(String path, String perms, String dirPerms)` Deprecated. use `rxChmodRecursive(java.lang.String, java.lang.String, java.lang.String)` instead
    `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
    `rx.Observable<Void>` | `chownObservable(String path, String user, String group)` Deprecated. use `rxChown(java.lang.String, java.lang.String, java.lang.String)` instead
    `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(java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
    `rx.Observable<Void>` | `copyObservable(String from, String to)` Deprecated. use `rxCopy(java.lang.String, java.lang.String)` instead
    `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(java.lang.String, java.lang.String, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
    `rx.Observable<Void>` | `copyRecursiveObservable(String from, String to, boolean recursive)` Deprecated. use `rxCopyRecursive(java.lang.String, java.lang.String, boolean)` instead
    `FileSystem` | `createFile(String path, Handler<AsyncResult<Void>> handler)` Creates an empty file with the specified `path`, asynchronously.
    `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(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
    `FileSystem` | `createFileBlocking(String path, String perms)` Blocking version of `createFile(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
    `rx.Observable<Void>` | `createFileObservable(String path)` Deprecated. use `rxCreateFile(java.lang.String)` instead
    `rx.Observable<Void>` | `createFileObservable(String path, String perms)` Deprecated. use `rxCreateFile(java.lang.String)` instead
    `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(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
    `rx.Observable<Void>` | `deleteObservable(String path)` Deprecated. use `rxDelete(java.lang.String)` instead
    `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(java.lang.String, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
    `rx.Observable<Void>` | `deleteRecursiveObservable(String path, boolean recursive)` Deprecated. use `rxDeleteRecursive(java.lang.String, boolean)` instead
    `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(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Boolean>>)`
    `rx.Observable<Boolean>` | `existsObservable(String path)` Deprecated. use `rxExists(java.lang.String)` instead
    `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(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.file.FileSystemProps>>)`
    `rx.Observable<FileSystemProps>` | `fsPropsObservable(String path)` Deprecated. use `rxFsProps(java.lang.String)` instead
    `FileSystem` | `getDelegate()`
    `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(java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
    `rx.Observable<Void>` | `linkObservable(String link, String existing)` Deprecated. use `rxLink(java.lang.String, java.lang.String)` instead
    `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(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.file.FileProps>>)`
    `rx.Observable<FileProps>` | `lpropsObservable(String path)` Deprecated. use `rxLprops(java.lang.String)` instead
    `FileSystem` | `mkdir(String path, Handler<AsyncResult<Void>> handler)` Create the directory represented by `path`, asynchronously.
    `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(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
    `FileSystem` | `mkdirBlocking(String path, String perms)` Blocking version of `mkdir(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
    `rx.Observable<Void>` | `mkdirObservable(String path)` Deprecated. use `rxMkdir(java.lang.String)` instead
    `rx.Observable<Void>` | `mkdirObservable(String path, String perms)` Deprecated. use `rxMkdir(java.lang.String)` instead
    `FileSystem` | `mkdirs(String path, Handler<AsyncResult<Void>> handler)` Create the directory represented by `path` and any non existent parents, asynchronously.
    `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(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
    `FileSystem` | `mkdirsBlocking(String path, String perms)` Blocking version of `mkdirs(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
    `rx.Observable<Void>` | `mkdirsObservable(String path)` Deprecated. use `rxMkdirs(java.lang.String)` instead
    `rx.Observable<Void>` | `mkdirsObservable(String path, String perms)` Deprecated. use `rxMkdirs(java.lang.String)` instead
    `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(java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
    `rx.Observable<Void>` | `moveObservable(String from, String to)` Deprecated. use `rxMove(java.lang.String, java.lang.String)` instead
    `static FileSystem` | `newInstance(FileSystem arg)`
    `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(java.lang.String, io.vertx.core.file.OpenOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.file.AsyncFile>>)`
    `rx.Observable<AsyncFile>` | `openObservable(String path, OpenOptions options)` Deprecated. use `rxOpen(java.lang.String, io.vertx.core.file.OpenOptions)` instead
    `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(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.file.FileProps>>)`
    `rx.Observable<FileProps>` | `propsObservable(String path)` Deprecated. use `rxProps(java.lang.String)` instead
    `FileSystem` | `readDir(String path, Handler<AsyncResult<List<String>>> handler)` Read the contents of the directory specified by `path`, asynchronously.
    `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(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.util.List<java.lang.String>>>)`
    `List<String>` | `readDirBlocking(String path, String filter)` Blocking version of `readDir(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.util.List<java.lang.String>>>)`
    `rx.Observable<List<String>>` | `readDirObservable(String path)` Deprecated. use `rxReadDir(java.lang.String)` instead
    `rx.Observable<List<String>>` | `readDirObservable(String path, String filter)` Deprecated. use `rxReadDir(java.lang.String)` instead
    `FileSystem` | `readFile(String path, Handler<AsyncResult<Buffer>> handler)` Reads the entire file as represented by the path `path` as a , asynchronously.
    `Buffer` | `readFileBlocking(String path)` Blocking version of `readFile(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.buffer.Buffer>>)`
    `rx.Observable<Buffer>` | `readFileObservable(String path)` Deprecated. use `rxReadFile(java.lang.String)` instead
    `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(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)`
    `rx.Observable<String>` | `readSymlinkObservable(String link)` Deprecated. use `rxReadSymlink(java.lang.String)` instead
    `rx.Single<Void>` | `rxChmod(String path, String perms)` Change the permissions on the file represented by `path` to `perms`, asynchronously.
    `rx.Single<Void>` | `rxChmodRecursive(String path, String perms, String dirPerms)` Change the permissions on the file represented by `path` to `perms`, asynchronously.
    `rx.Single<Void>` | `rxChown(String path, String user, String group)` Change the ownership on the file represented by `path` to `user` and {code group}, asynchronously.
    `rx.Single<Void>` | `rxCopy(String from, String to)` Copy a file from the path `from` to path `to`, asynchronously.
    `rx.Single<Void>` | `rxCopyRecursive(String from, String to, boolean recursive)` Copy a file from the path `from` to path `to`, asynchronously.
    `rx.Single<Void>` | `rxCreateFile(String path)` Creates an empty file with the specified `path`, asynchronously.
    `rx.Single<Void>` | `rxCreateFile(String path, String perms)` Creates an empty file with the specified `path` and permissions `perms`, asynchronously.
    `rx.Single<Void>` | `rxDelete(String path)` Deletes the file represented by the specified `path`, asynchronously.
    `rx.Single<Void>` | `rxDeleteRecursive(String path, boolean recursive)` Deletes the file represented by the specified `path`, asynchronously.
    `rx.Single<Boolean>` | `rxExists(String path)` Determines whether the file as specified by the path `path` exists, asynchronously.
    `rx.Single<FileSystemProps>` | `rxFsProps(String path)` Returns properties of the file-system being used by the specified `path`, asynchronously.
    `rx.Single<Void>` | `rxLink(String link, String existing)` Create a hard link on the file system from `link` to `existing`, asynchronously.
    `rx.Single<FileProps>` | `rxLprops(String path)` Obtain properties for the link represented by `path`, asynchronously.
    `rx.Single<Void>` | `rxMkdir(String path)` Create the directory represented by `path`, asynchronously.
    `rx.Single<Void>` | `rxMkdir(String path, String perms)` Create the directory represented by `path`, asynchronously.
    `rx.Single<Void>` | `rxMkdirs(String path)` Create the directory represented by `path` and any non existent parents, asynchronously.
    `rx.Single<Void>` | `rxMkdirs(String path, String perms)` Create the directory represented by `path` and any non existent parents, asynchronously.
    `rx.Single<Void>` | `rxMove(String from, String to)` Move a file from the path `from` to path `to`, asynchronously.
    `rx.Single<AsyncFile>` | `rxOpen(String path, OpenOptions options)` Open the file represented by `path`, asynchronously.
    `rx.Single<FileProps>` | `rxProps(String path)` Obtain properties for the file represented by `path`, asynchronously.
    `rx.Single<List<String>>` | `rxReadDir(String path)` Read the contents of the directory specified by `path`, asynchronously.
    `rx.Single<List<String>>` | `rxReadDir(String path, String filter)` Read the contents of the directory specified by `path`, asynchronously.
    `rx.Single<Buffer>` | `rxReadFile(String path)` Reads the entire file as represented by the path `path` as a , asynchronously.
    `rx.Single<String>` | `rxReadSymlink(String link)` Returns the path representing the file that the symbolic link specified by `link` points to, asynchronously.
    `rx.Single<Void>` | `rxSymlink(String link, String existing)` Create a symbolic link on the file system from `link` to `existing`, asynchronously.
    `rx.Single<Void>` | `rxTruncate(String path, long len)` Truncate the file represented by `path` to length `len` in bytes, asynchronously.
    `rx.Single<Void>` | `rxUnlink(String link)` Unlinks the link on the file system represented by the path `link`, asynchronously.
    `rx.Single<Void>` | `rxWriteFile(String path, Buffer data)` Creates the file, and writes the specified `Buffer data` to the file represented by the path `path`, asynchronously.
    `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(java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
    `rx.Observable<Void>` | `symlinkObservable(String link, String existing)` Deprecated. use `rxSymlink(java.lang.String, java.lang.String)` instead
    `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(java.lang.String, long, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
    `rx.Observable<Void>` | `truncateObservable(String path, long len)` Deprecated. use `rxTruncate(java.lang.String, long)` instead
    `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(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
    `rx.Observable<Void>` | `unlinkObservable(String link)` Deprecated. use `rxUnlink(java.lang.String)` instead
    `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(java.lang.String, io.vertx.rxjava.core.buffer.Buffer, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
    `rx.Observable<Void>` | `writeFileObservable(String path, Buffer data)` Deprecated. use `rxWriteFile(java.lang.String, io.vertx.rxjava.core.buffer.Buffer)` instead

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### __TYPE_ARG

          public static final TypeArg<FileSystem> __TYPE_ARG

  - ### Constructor Detail

    - #### FileSystem

          public FileSystem(FileSystem delegate)

  - ### Method Detail

    - #### getDelegate

          public FileSystem getDelegate()

    - #### copy

          public 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

    - #### copyObservable

          @Deprecated
          public rx.Observable<Void> copyObservable(String from,
                                                                String to)

      Deprecated. use `rxCopy(java.lang.String, java.lang.String)` instead
      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
      Returns:

    - #### rxCopy

          public rx.Single<Void> rxCopy(String from,
                                        String to)

      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
      Returns:

    - #### copyBlocking

          public FileSystem copyBlocking(String from,
                                         String to)

      Blocking version of `copy(java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
      Parameters:
        `from` -
        `to` -
      Returns:

    - #### copyRecursive

          public 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

    - #### copyRecursiveObservable

          @Deprecated
          public rx.Observable<Void> copyRecursiveObservable(String from,
                                                                         String to,
                                                                         boolean recursive)

      Deprecated. use `rxCopyRecursive(java.lang.String, java.lang.String, boolean)` instead
      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` -
      Returns:

    - #### rxCopyRecursive

          public rx.Single<Void> rxCopyRecursive(String from,
                                                 String to,
                                                 boolean recursive)

      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` -
      Returns:

    - #### copyRecursiveBlocking

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

      Blocking version of `copyRecursive(java.lang.String, java.lang.String, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
      Parameters:
        `from` -
        `to` -
        `recursive` -
      Returns:

    - #### move

          public 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

    - #### moveObservable

          @Deprecated
          public rx.Observable<Void> moveObservable(String from,
                                                                String to)

      Deprecated. use `rxMove(java.lang.String, java.lang.String)` instead
      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
      Returns:

    - #### rxMove

          public rx.Single<Void> rxMove(String from,
                                        String to)

      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
      Returns:

    - #### moveBlocking

          public FileSystem moveBlocking(String from,
                                         String to)

      Blocking version of `move(java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
      Parameters:
        `from` -
        `to` -
      Returns:

    - #### truncate

          public 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

    - #### truncateObservable

          @Deprecated
          public rx.Observable<Void> truncateObservable(String path,
                                                                    long len)

      Deprecated. use `rxTruncate(java.lang.String, long)` instead
      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
      Returns:

    - #### rxTruncate

          public rx.Single<Void> rxTruncate(String path,
                                            long len)

      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
      Returns:

    - #### truncateBlocking

          public FileSystem truncateBlocking(String path,
                                             long len)

      Blocking version of `truncate(java.lang.String, long, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
      Parameters:
        `path` -
        `len` -
      Returns:

    - #### chmod

          public 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

    - #### chmodObservable

          @Deprecated
          public rx.Observable<Void> chmodObservable(String path,
                                                                 String perms)

      Deprecated. use `rxChmod(java.lang.String, java.lang.String)` instead
      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
      Returns:

    - #### rxChmod

          public rx.Single<Void> rxChmod(String path,
                                         String perms)

      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
      Returns:

    - #### chmodBlocking

          public FileSystem chmodBlocking(String path,
                                          String perms)

      Blocking version of `#chmod(String, String, Handler)`
      Parameters:
        `path` -
        `perms` -
      Returns:

    - #### chmodRecursive

          public 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

    - #### chmodRecursiveObservable

          @Deprecated
          public rx.Observable<Void> chmodRecursiveObservable(String path,
                                                                          String perms,
                                                                          String dirPerms)

      Deprecated. use `rxChmodRecursive(java.lang.String, java.lang.String, java.lang.String)` instead
      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
      Returns:

    - #### rxChmodRecursive

          public rx.Single<Void> rxChmodRecursive(String path,
                                                  String perms,
                                                  String dirPerms)

      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
      Returns:

    - #### chmodRecursiveBlocking

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

      Blocking version of `chmodRecursive(java.lang.String, java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
      Parameters:
        `path` -
        `perms` -
        `dirPerms` -
      Returns:

    - #### chown

          public 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

    - #### chownObservable

          @Deprecated
          public rx.Observable<Void> chownObservable(String path,
                                                                 String user,
                                                                 String group)

      Deprecated. use `rxChown(java.lang.String, java.lang.String, java.lang.String)` instead
      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
      Returns:

    - #### rxChown

          public rx.Single<Void> rxChown(String path,
                                         String user,
                                         String group)

      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
      Returns:

    - #### chownBlocking

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

      Blocking version of
      Parameters:
        `path` -
        `user` -
        `group` -
      Returns:

    - #### props

          public 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

    - #### propsObservable

          @Deprecated
          public rx.Observable<FileProps> propsObservable(String path)

      Deprecated. use `rxProps(java.lang.String)` instead
      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
      Returns:

    - #### rxProps

          public rx.Single<FileProps> rxProps(String path)

      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
      Returns:

    - #### propsBlocking

          public FileProps propsBlocking(String path)

      Blocking version of `props(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.file.FileProps>>)`
      Parameters:
        `path` -
      Returns:

    - #### lprops

          public 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

    - #### lpropsObservable

          @Deprecated
          public rx.Observable<FileProps> lpropsObservable(String path)

      Deprecated. use `rxLprops(java.lang.String)` instead
      Obtain properties for the link represented by `path`, asynchronously.

      The link will not be followed.

      Parameters:
        `path` - the path to the file
      Returns:

    - #### rxLprops

          public rx.Single<FileProps> rxLprops(String path)

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

      The link will not be followed.

      Parameters:
        `path` - the path to the file
      Returns:

    - #### lpropsBlocking

          public FileProps lpropsBlocking(String path)

      Blocking version of `lprops(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.file.FileProps>>)`
      Parameters:
        `path` -
      Returns:

    - #### link

          public 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

    - #### linkObservable

          @Deprecated
          public rx.Observable<Void> linkObservable(String link,
                                                                String existing)

      Deprecated. use `rxLink(java.lang.String, java.lang.String)` instead
      Create a hard link on the file system from `link` to `existing`, asynchronously.
      Parameters:
        `link` - the link
        `existing` - the link destination
      Returns:

    - #### rxLink

          public rx.Single<Void> rxLink(String link,
                                        String existing)

      Create a hard link on the file system from `link` to `existing`, asynchronously.
      Parameters:
        `link` - the link
        `existing` - the link destination
      Returns:

    - #### linkBlocking

          public FileSystem linkBlocking(String link,
                                         String existing)

      Blocking version of `link(java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
      Parameters:
        `link` -
        `existing` -
      Returns:

    - #### symlink

          public 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

    - #### symlinkObservable

          @Deprecated
          public rx.Observable<Void> symlinkObservable(String link,
                                                                   String existing)

      Deprecated. use `rxSymlink(java.lang.String, java.lang.String)` instead
      Create a symbolic link on the file system from `link` to `existing`, asynchronously.
      Parameters:
        `link` - the link
        `existing` - the link destination
      Returns:

    - #### rxSymlink

          public rx.Single<Void> rxSymlink(String link,
                                           String existing)

      Create a symbolic link on the file system from `link` to `existing`, asynchronously.
      Parameters:
        `link` - the link
        `existing` - the link destination
      Returns:

    - #### symlinkBlocking

          public FileSystem symlinkBlocking(String link,
                                            String existing)

      Blocking version of `link(java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
      Parameters:
        `link` -
        `existing` -
      Returns:

    - #### unlink

          public 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

    - #### unlinkObservable

          @Deprecated
          public rx.Observable<Void> unlinkObservable(String link)

      Deprecated. use `rxUnlink(java.lang.String)` instead
      Unlinks the link on the file system represented by the path `link`, asynchronously.
      Parameters:
        `link` - the link
      Returns:

    - #### rxUnlink

          public rx.Single<Void> rxUnlink(String link)

      Unlinks the link on the file system represented by the path `link`, asynchronously.
      Parameters:
        `link` - the link
      Returns:

    - #### unlinkBlocking

          public FileSystem unlinkBlocking(String link)

      Blocking version of `unlink(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
      Parameters:
        `link` -
      Returns:

    - #### readSymlink

          public 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

    - #### readSymlinkObservable

          @Deprecated
          public rx.Observable<String> readSymlinkObservable(String link)

      Deprecated. use `rxReadSymlink(java.lang.String)` instead
      Returns the path representing the file that the symbolic link specified by `link` points to, asynchronously.
      Parameters:
        `link` - the link
      Returns:

    - #### rxReadSymlink

          public rx.Single<String> rxReadSymlink(String link)

      Returns the path representing the file that the symbolic link specified by `link` points to, asynchronously.
      Parameters:
        `link` - the link
      Returns:

    - #### readSymlinkBlocking

          public String readSymlinkBlocking(String link)

      Blocking version of `readSymlink(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)`
      Parameters:
        `link` -
      Returns:

    - #### delete

          public 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

    - #### deleteObservable

          @Deprecated
          public rx.Observable<Void> deleteObservable(String path)

      Deprecated. use `rxDelete(java.lang.String)` instead
      Deletes the file represented by the specified `path`, asynchronously.
      Parameters:
        `path` - path to the file
      Returns:

    - #### rxDelete

          public rx.Single<Void> rxDelete(String path)

      Deletes the file represented by the specified `path`, asynchronously.
      Parameters:
        `path` - path to the file
      Returns:

    - #### deleteBlocking

          public FileSystem deleteBlocking(String path)

      Blocking version of `delete(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
      Parameters:
        `path` -
      Returns:

    - #### deleteRecursive

          public 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

    - #### deleteRecursiveObservable

          @Deprecated
          public rx.Observable<Void> deleteRecursiveObservable(String path,
                                                                           boolean recursive)

      Deprecated. use `rxDeleteRecursive(java.lang.String, boolean)` instead
      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?
      Returns:

    - #### rxDeleteRecursive

          public rx.Single<Void> rxDeleteRecursive(String path,
                                                   boolean recursive)

      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?
      Returns:

    - #### deleteRecursiveBlocking

          public FileSystem deleteRecursiveBlocking(String path,
                                                    boolean recursive)

      Blocking version of `deleteRecursive(java.lang.String, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
      Parameters:
        `path` -
        `recursive` -
      Returns:

    - #### mkdir

          public 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

    - #### mkdirObservable

          @Deprecated
          public rx.Observable<Void> mkdirObservable(String path)

      Deprecated. use `rxMkdir(java.lang.String)` instead
      Create the directory represented by `path`, asynchronously.

      The operation will fail if the directory already exists.

      Parameters:
        `path` - path to the file
      Returns:

    - #### rxMkdir

          public rx.Single<Void> rxMkdir(String path)

      Create the directory represented by `path`, asynchronously.

      The operation will fail if the directory already exists.

      Parameters:
        `path` - path to the file
      Returns:

    - #### mkdirBlocking

          public FileSystem mkdirBlocking(String path)

      Blocking version of `mkdir(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
      Parameters:
        `path` -
      Returns:

    - #### mkdir

          public 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

    - #### mkdirObservable

          @Deprecated
          public rx.Observable<Void> mkdirObservable(String path,
                                                                 String perms)

      Deprecated. use `rxMkdir(java.lang.String)` instead
      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
      Returns:

    - #### rxMkdir

          public rx.Single<Void> rxMkdir(String path,
                                         String perms)

      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
      Returns:

    - #### mkdirBlocking

          public FileSystem mkdirBlocking(String path,
                                          String perms)

      Blocking version of `mkdir(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
      Parameters:
        `path` -
        `perms` -
      Returns:

    - #### mkdirs

          public 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 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

    - #### mkdirsObservable

          @Deprecated
          public rx.Observable<Void> mkdirsObservable(String path)

      Deprecated. use `rxMkdirs(java.lang.String)` instead
      Create the directory represented by `path` and any non existent parents, asynchronously.

      The operation will fail if the directory already exists.

      Parameters:
        `path` - path to the file
      Returns:

    - #### rxMkdirs

          public rx.Single<Void> rxMkdirs(String path)

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

      The operation will fail if the directory already exists.

      Parameters:
        `path` - path to the file
      Returns:

    - #### mkdirsBlocking

          public FileSystem mkdirsBlocking(String path)

      Blocking version of `mkdirs(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
      Parameters:
        `path` -
      Returns:

    - #### mkdirs

          public 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 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

    - #### mkdirsObservable

          @Deprecated
          public rx.Observable<Void> mkdirsObservable(String path,
                                                                  String perms)

      Deprecated. use `rxMkdirs(java.lang.String)` instead
      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 directory already exists.

      Parameters:
        `path` - path to the file
        `perms` - the permissions string
      Returns:

    - #### rxMkdirs

          public rx.Single<Void> rxMkdirs(String path,
                                          String perms)

      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 directory already exists.

      Parameters:
        `path` - path to the file
        `perms` - the permissions string
      Returns:

    - #### mkdirsBlocking

          public FileSystem mkdirsBlocking(String path,
                                           String perms)

      Blocking version of `mkdirs(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
      Parameters:
        `path` -
        `perms` -
      Returns:

    - #### readDir

          public 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

    - #### readDirObservable

          @Deprecated
          public rx.Observable<List<String>> readDirObservable(String path)

      Deprecated. use `rxReadDir(java.lang.String)` instead
      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
      Returns:

    - #### rxReadDir

          public rx.Single<List<String>> rxReadDir(String path)

      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
      Returns:

    - #### readDirBlocking

          public List<String> readDirBlocking(String path)

      Blocking version of `readDir(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.util.List<java.lang.String>>>)`
      Parameters:
        `path` -
      Returns:

    - #### readDir

          public 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

    - #### readDirObservable

          @Deprecated
          public rx.Observable<List<String>> readDirObservable(String path,
                                                                           String filter)

      Deprecated. use `rxReadDir(java.lang.String)` instead
      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
      Returns:

    - #### rxReadDir

          public rx.Single<List<String>> rxReadDir(String path,
                                                   String filter)

      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
      Returns:

    - #### readDirBlocking

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

      Blocking version of `readDir(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.util.List<java.lang.String>>>)`
      Parameters:
        `path` -
        `filter` -
      Returns:

    - #### readFile

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

      Reads the entire file as represented by the path `path` as a , 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

    - #### readFileObservable

          @Deprecated
          public rx.Observable<Buffer> readFileObservable(String path)

      Deprecated. use `rxReadFile(java.lang.String)` instead
      Reads the entire file as represented by the path `path` as a , 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
      Returns:

    - #### rxReadFile

          public rx.Single<Buffer> rxReadFile(String path)

      Reads the entire file as represented by the path `path` as a , 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
      Returns:

    - #### readFileBlocking

          public Buffer readFileBlocking(String path)

      Blocking version of `readFile(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.buffer.Buffer>>)`
      Parameters:
        `path` -
      Returns:

    - #### writeFile

          public 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
        `data` -
        `handler` - the handler that will be called on completion
      Returns:
        a reference to this, so the API can be used fluently

    - #### writeFileObservable

          @Deprecated
          public rx.Observable<Void> writeFileObservable(String path,
                                                                     Buffer data)

      Deprecated. use `rxWriteFile(java.lang.String, io.vertx.rxjava.core.buffer.Buffer)` instead
      Creates the file, and writes the specified `Buffer data` to the file represented by the path `path`, asynchronously.
      Parameters:
        `path` - path to the file
        `data` -
      Returns:

    - #### rxWriteFile

          public rx.Single<Void> rxWriteFile(String path,
                                             Buffer data)

      Creates the file, and writes the specified `Buffer data` to the file represented by the path `path`, asynchronously.
      Parameters:
        `path` - path to the file
        `data` -
      Returns:

    - #### writeFileBlocking

          public FileSystem writeFileBlocking(String path,
                                              Buffer data)

      Blocking version of `writeFile(java.lang.String, io.vertx.rxjava.core.buffer.Buffer, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
      Parameters:
        `path` -
        `data` -
      Returns:

    - #### open

          public 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
        `handler` -
      Returns:
        a reference to this, so the API can be used fluently

    - #### openObservable

          @Deprecated
          public rx.Observable<AsyncFile> openObservable(String path,
                                                                     OpenOptions options)

      Deprecated. use `rxOpen(java.lang.String, io.vertx.core.file.OpenOptions)` instead
      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:

    - #### rxOpen

          public rx.Single<AsyncFile> rxOpen(String path,
                                             OpenOptions options)

      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:

    - #### openBlocking

          public AsyncFile openBlocking(String path,
                                        OpenOptions options)

      Blocking version of `open(java.lang.String, io.vertx.core.file.OpenOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.file.AsyncFile>>)`
      Parameters:
        `path` -
        `options` -
      Returns:

    - #### createFile

          public 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

    - #### createFileObservable

          @Deprecated
          public rx.Observable<Void> createFileObservable(String path)

      Deprecated. use `rxCreateFile(java.lang.String)` instead
      Creates an empty file with the specified `path`, asynchronously.
      Parameters:
        `path` - path to the file
      Returns:

    - #### rxCreateFile

          public rx.Single<Void> rxCreateFile(String path)

      Creates an empty file with the specified `path`, asynchronously.
      Parameters:
        `path` - path to the file
      Returns:

    - #### createFileBlocking

          public FileSystem createFileBlocking(String path)

      Blocking version of `createFile(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
      Parameters:
        `path` -
      Returns:

    - #### createFile

          public 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

    - #### createFileObservable

          @Deprecated
          public rx.Observable<Void> createFileObservable(String path,
                                                                      String perms)

      Deprecated. use `rxCreateFile(java.lang.String)` instead
      Creates an empty file with the specified `path` and permissions `perms`, asynchronously.
      Parameters:
        `path` - path to the file
        `perms` - the permissions string
      Returns:

    - #### rxCreateFile

          public rx.Single<Void> rxCreateFile(String path,
                                              String perms)

      Creates an empty file with the specified `path` and permissions `perms`, asynchronously.
      Parameters:
        `path` - path to the file
        `perms` - the permissions string
      Returns:

    - #### createFileBlocking

          public FileSystem createFileBlocking(String path,
                                               String perms)

      Blocking version of `createFile(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
      Parameters:
        `path` -
        `perms` -
      Returns:

    - #### exists

          public 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

    - #### existsObservable

          @Deprecated
          public rx.Observable<Boolean> existsObservable(String path)

      Deprecated. use `rxExists(java.lang.String)` instead
      Determines whether the file as specified by the path `path` exists, asynchronously.
      Parameters:
        `path` - path to the file
      Returns:

    - #### rxExists

          public rx.Single<Boolean> rxExists(String path)

      Determines whether the file as specified by the path `path` exists, asynchronously.
      Parameters:
        `path` - path to the file
      Returns:

    - #### existsBlocking

          public boolean existsBlocking(String path)

      Blocking version of `exists(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Boolean>>)`
      Parameters:
        `path` -
      Returns:

    - #### fsProps

          public 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

    - #### fsPropsObservable

          @Deprecated
          public rx.Observable<FileSystemProps> fsPropsObservable(String path)

      Deprecated. use `rxFsProps(java.lang.String)` instead
      Returns properties of the file-system being used by the specified `path`, asynchronously.
      Parameters:
        `path` - path to anywhere on the filesystem
      Returns:

    - #### rxFsProps

          public rx.Single<FileSystemProps> rxFsProps(String path)

      Returns properties of the file-system being used by the specified `path`, asynchronously.
      Parameters:
        `path` - path to anywhere on the filesystem
      Returns:

    - #### fsPropsBlocking

          public FileSystemProps fsPropsBlocking(String path)

      Blocking version of `fsProps(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.file.FileSystemProps>>)`
      Parameters:
        `path` -
      Returns:

    - #### newInstance

          public static FileSystem newInstance(FileSystem arg)

Copyright © 2017. All rights reserved.