FileSystem (Vert.x Stack - Docs 3.9.15 API)

java.lang.Object
- io.vertx.reactivex.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 io.vertx.lang.rx.TypeArg<FileSystem> __TYPE_ARG

Fields
Modifier and Type	Field and Description
`static io.vertx.lang.rx.TypeArg<FileSystem>`	`__TYPE_ARG`

Constructor Summary

Constructors
Constructor and Description

FileSystem(FileSystem delegate)

FileSystem(Object delegate)

Constructors
Constructor and Description
`FileSystem(FileSystem delegate)`
`FileSystem(Object delegate)`

Method Summary

All Methods Static Methods Instance Methods Concrete 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)`
`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>>)`
`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
`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(java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
`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>>)`
`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>>)`
`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.
`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.
`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(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)`
`String`	`createTempDirectoryBlocking(String prefix, String perms)` Blocking version of `createTempDirectory(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)`
`String`	`createTempDirectoryBlocking(String dir, String prefix, String perms)` Blocking version of `createTempDirectory(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)`
`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.
`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.
`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(java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)`
`String`	`createTempFileBlocking(String prefix, String suffix, String perms)` Blocking version of `createTempFile(java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)`
`String`	`createTempFileBlocking(String dir, String prefix, String suffix, String perms)` Blocking version of `createTempFile(java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)`
`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>>)`
`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>>)`
`boolean`	`equals(Object o)`
`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>>)`
`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.reactivex.core.file.FileSystemProps>>)`
`FileSystem`	`getDelegate()`
`int`	`hashCode()`
`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>>)`
`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.reactivex.core.file.FileProps>>)`
`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>>)`
`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>>)`
`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(java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
`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.reactivex.core.file.AsyncFile>>)`
`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.reactivex.core.file.FileProps>>)`
`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>>>)`
`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.reactivex.core.buffer.Buffer>>)`
`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>>)`
`Completable`	`rxChmod(String path, String perms)` Change the permissions on the file represented by `path` to `perms`, asynchronously.
`Completable`	`rxChmodRecursive(String path, String perms, String dirPerms)` Change the permissions on the file represented by `path` to `perms`, asynchronously.
`Completable`	`rxChown(String path, String user, String group)` Change the ownership on the file represented by `path` to `user` and {code group}, asynchronously.
`Completable`	`rxCopy(String from, String to)` Copy a file from the path `from` to path `to`, asynchronously.
`Completable`	`rxCopy(String from, String to, CopyOptions options)` Copy a file from the path `from` to path `to`, asynchronously.
`Completable`	`rxCopyRecursive(String from, String to, boolean recursive)` Copy a file from the path `from` to path `to`, asynchronously.
`Completable`	`rxCreateFile(String path)` Creates an empty file with the specified `path`, asynchronously.
`Completable`	`rxCreateFile(String path, String perms)` Creates an empty file with the specified `path` and permissions `perms`, asynchronously.
`Single<String>`	`rxCreateTempDirectory(String prefix)` Creates a new directory in the default temporary-file directory, using the given prefix to generate its name, asynchronously.
`Single<String>`	`rxCreateTempDirectory(String prefix, String perms)` Creates a new directory in the default temporary-file directory, using the given prefix to generate its name, asynchronously.
`Single<String>`	`rxCreateTempDirectory(String dir, String prefix, String perms)` Creates a new directory in the directory provided by the path `path`, using the given prefix to generate its name, asynchronously.
`Single<String>`	`rxCreateTempFile(String prefix, String suffix)` Creates a new file in the default temporary-file directory, using the given prefix and suffix to generate its name, asynchronously.
`Single<String>`	`rxCreateTempFile(String prefix, String suffix, String perms)` Creates a new file in the directory provided by the path `dir`, using the given prefix and suffix to generate its name, asynchronously.
`Single<String>`	`rxCreateTempFile(String dir, String prefix, String suffix, String perms)` Creates a new file in the directory provided by the path `dir`, using the given prefix and suffix to generate its name, asynchronously.
`Completable`	`rxDelete(String path)` Deletes the file represented by the specified `path`, asynchronously.
`Completable`	`rxDeleteRecursive(String path, boolean recursive)` Deletes the file represented by the specified `path`, asynchronously.
`Single<Boolean>`	`rxExists(String path)` Determines whether the file as specified by the path `path` exists, asynchronously.
`Single<FileSystemProps>`	`rxFsProps(String path)` Returns properties of the file-system being used by the specified `path`, asynchronously.
`Completable`	`rxLink(String link, String existing)` Create a hard link on the file system from `link` to `existing`, asynchronously.
`Single<FileProps>`	`rxLprops(String path)` Obtain properties for the link represented by `path`, asynchronously.
`Completable`	`rxMkdir(String path)` Create the directory represented by `path`, asynchronously.
`Completable`	`rxMkdir(String path, String perms)` Create the directory represented by `path`, asynchronously.
`Completable`	`rxMkdirs(String path)` Create the directory represented by `path` and any non existent parents, asynchronously.
`Completable`	`rxMkdirs(String path, String perms)` Create the directory represented by `path` and any non existent parents, asynchronously.
`Completable`	`rxMove(String from, String to)` Move a file from the path `from` to path `to`, asynchronously.
`Completable`	`rxMove(String from, String to, CopyOptions options)` Move a file from the path `from` to path `to`, asynchronously.
`Single<AsyncFile>`	`rxOpen(String path, OpenOptions options)` Open the file represented by `path`, asynchronously.
`Single<FileProps>`	`rxProps(String path)` Obtain properties for the file represented by `path`, asynchronously.
`Single<List<String>>`	`rxReadDir(String path)` Read the contents of the directory specified by `path`, asynchronously.
`Single<List<String>>`	`rxReadDir(String path, String filter)` Read the contents of the directory specified by `path`, asynchronously.
`Single<Buffer>`	`rxReadFile(String path)` Reads the entire file as represented by the path `path` as a , asynchronously.
`Single<String>`	`rxReadSymlink(String link)` Returns the path representing the file that the symbolic link specified by `link` points to, asynchronously.
`Completable`	`rxSymlink(String link, String existing)` Create a symbolic link on the file system from `link` to `existing`, asynchronously.
`Completable`	`rxTruncate(String path, long len)` Truncate the file represented by `path` to length `len` in bytes, asynchronously.
`Completable`	`rxUnlink(String link)` Unlinks the link on the file system represented by the path `link`, asynchronously.
`Completable`	`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>>)`
`String`	`toString()`
`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>>)`
`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>>)`
`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.reactivex.core.buffer.Buffer, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - __TYPE_ARG
```
public static final io.vertx.lang.rx.TypeArg<FileSystem> __TYPE_ARG
```
- Constructor Detail
  - FileSystem
```
public FileSystem(FileSystem delegate)
```
  - FileSystem
```
public FileSystem(Object delegate)
```
- Method Detail
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - equals
```
public boolean equals(Object o)
```
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - 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
  - rxCopy
```
public Completable 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:
    
    a reference to this, so the API can be used fluently
  - copy
```
public 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
  - rxCopy
```
public Completable rxCopy(String from,
                          String to,
                          CopyOptions options)
```
    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
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - 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
  - rxCopyRecursive
```
public Completable 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:
    
    a reference to this, so the API can be used fluently
  - 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
  - rxMove
```
public Completable 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:
    
    a reference to this, so the API can be used fluently
  - move
```
public 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
  - rxMove
```
public Completable rxMove(String from,
                          String to,
                          CopyOptions options)
```
    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
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - 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
  - rxTruncate
```
public Completable 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:
    
    a reference to this, so the API can be used fluently
  - 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
  - rxChmod
```
public Completable 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:
    
    a reference to this, so the API can be used fluently
  - 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
  - rxChmodRecursive
```
public Completable 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:
    
    a reference to this, so the API can be used fluently
  - 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
  - rxChown
```
public Completable 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:
    
    a reference to this, so the API can be used fluently
  - 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
  - rxProps
```
public 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:
    
    a reference to this, so the API can be used fluently
  - propsBlocking
```
public FileProps propsBlocking(String path)
```
    Blocking version of props(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.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
  - rxLprops
```
public 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:
    
    a reference to this, so the API can be used fluently
  - lpropsBlocking
```
public FileProps lpropsBlocking(String path)
```
    Blocking version of lprops(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.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
  - rxLink
```
public Completable 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:
    
    a reference to this, so the API can be used fluently
  - 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
  - rxSymlink
```
public Completable 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:
    
    a reference to this, so the API can be used fluently
  - 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
  - rxUnlink
```
public Completable rxUnlink(String link)
```
    Unlinks the link on the file system represented by the path link, asynchronously.
    
    Parameters:
    
    link - the link
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - 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
  - rxReadSymlink
```
public 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:
    
    a reference to this, so the API can be used fluently
  - 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
  - rxDelete
```
public Completable rxDelete(String path)
```
    Deletes the file represented by the specified path, asynchronously.
    
    Parameters:
    
    path - path to the file
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - 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
  - rxDeleteRecursive
```
public Completable 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:
    
    a reference to this, so the API can be used fluently
  - 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
  - rxMkdir
```
public Completable 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:
    
    a reference to this, so the API can be used fluently
  - 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
  - rxMkdir
```
public Completable 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:
    
    a reference to this, so the API can be used fluently
  - 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 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
  - rxMkdirs
```
public Completable rxMkdirs(String path)
```
    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
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - 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 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
  - rxMkdirs
```
public Completable 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 path already exists but is not a directory.
    
    Parameters:
    
    path - path to the file
    
    perms - the permissions string
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - 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
  - rxReadDir
```
public 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:
    
    a reference to this, so the API can be used fluently
  - 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
  - rxReadDir
```
public 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:
    
    a reference to this, so the API can be used fluently
  - 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
  - rxReadFile
```
public 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:
    
    a reference to this, so the API can be used fluently
  - readFileBlocking
```
public Buffer readFileBlocking(String path)
```
    Blocking version of readFile(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.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
  - rxWriteFile
```
public Completable 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:
    
    a reference to this, so the API can be used fluently
  - writeFileBlocking
```
public FileSystem writeFileBlocking(String path,
                                    Buffer data)
```
    Blocking version of writeFile(java.lang.String, io.vertx.reactivex.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
  - rxOpen
```
public 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:
    
    a reference to this, so the API can be used fluently
  - 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.reactivex.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
  - rxCreateFile
```
public Completable rxCreateFile(String path)
```
    Creates an empty file with the specified path, asynchronously.
    
    Parameters:
    
    path - path to the file
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - 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
  - rxCreateFile
```
public Completable 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:
    
    a reference to this, so the API can be used fluently
  - 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
  - rxExists
```
public Single<Boolean> rxExists(String path)
```
    Determines whether the file as specified by the path path exists, asynchronously.
    
    Parameters:
    
    path - path to the file
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - 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
  - rxFsProps
```
public 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:
    
    a reference to this, so the API can be used fluently
  - fsPropsBlocking
```
public FileSystemProps fsPropsBlocking(String path)
```
    Blocking version of fsProps(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.file.FileSystemProps>>)
    
    Parameters:
    
    path -
    
    Returns:
  - createTempDirectory
```
public 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 Runtime, or the File 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
  - rxCreateTempDirectory
```
public Single<String> rxCreateTempDirectory(String prefix)
```
    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 Runtime, or the File 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
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - createTempDirectoryBlocking
```
public String createTempDirectoryBlocking(String prefix)
```
    Blocking version of createTempDirectory(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)
    
    Parameters:
    
    prefix -
    
    Returns:
  - createTempDirectory
```
public 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 Runtime, or the File 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
  - rxCreateTempDirectory
```
public Single<String> rxCreateTempDirectory(String prefix,
                                            String perms)
```
    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 Runtime, or the File 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
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - createTempDirectoryBlocking
```
public String createTempDirectoryBlocking(String prefix,
                                          String perms)
```
    Blocking version of createTempDirectory(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)
    
    Parameters:
    
    prefix -
    
    perms -
    
    Returns:
  - createTempDirectory
```
public 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 Runtime, or the File 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
  - rxCreateTempDirectory
```
public Single<String> rxCreateTempDirectory(String dir,
                                            String prefix,
                                            String perms)
```
    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 Runtime, or the File 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
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - createTempDirectoryBlocking
```
public String createTempDirectoryBlocking(String dir,
                                          String prefix,
                                          String perms)
```
    Blocking version of createTempDirectory(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)
    
    Parameters:
    
    dir -
    
    prefix -
    
    perms -
    
    Returns:
  - createTempFile
```
public 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 Runtime, or the File 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
  - rxCreateTempFile
```
public Single<String> rxCreateTempFile(String prefix,
                                       String suffix)
```
    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 Runtime, or the File 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
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - createTempFileBlocking
```
public String createTempFileBlocking(String prefix,
                                     String suffix)
```
    Blocking version of createTempFile(java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)
    
    Parameters:
    
    prefix -
    
    suffix -
    
    Returns:
  - createTempFile
```
public 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 Runtime, or the File 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
    
    perms -
    
    handler - the handler that will be called on completion
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - rxCreateTempFile
```
public Single<String> rxCreateTempFile(String prefix,
                                       String suffix,
                                       String perms)
```
    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 Runtime, or the File 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
    
    perms -
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - createTempFileBlocking
```
public String createTempFileBlocking(String prefix,
                                     String suffix,
                                     String perms)
```
    Blocking version of createTempFile(java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)
    
    Parameters:
    
    prefix -
    
    suffix -
    
    perms -
    
    Returns:
  - createTempFile
```
public 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 Runtime, or the File 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
  - rxCreateTempFile
```
public Single<String> rxCreateTempFile(String dir,
                                       String prefix,
                                       String suffix,
                                       String perms)
```
    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 Runtime, or the File 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
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - createTempFileBlocking
```
public String createTempFileBlocking(String dir,
                                     String prefix,
                                     String suffix,
                                     String perms)
```
    Blocking version of createTempFile(java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)
    
    Parameters:
    
    dir -
    
    prefix -
    
    suffix -
    
    perms -
    
    Returns:
  - newInstance
```
public static FileSystem newInstance(FileSystem arg)
```

Class FileSystem

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

__TYPE_ARG

Constructor Detail

FileSystem

FileSystem

Method Detail

toString

equals

hashCode

getDelegate

copy

rxCopy

copy

rxCopy

copyBlocking

copyRecursive

rxCopyRecursive

copyRecursiveBlocking

move

rxMove

move

rxMove

moveBlocking

truncate

rxTruncate

truncateBlocking

chmod

rxChmod

chmodBlocking

chmodRecursive

rxChmodRecursive

chmodRecursiveBlocking

chown

rxChown

chownBlocking

props

rxProps

propsBlocking

lprops

rxLprops

lpropsBlocking

link

rxLink

linkBlocking

symlink

rxSymlink

symlinkBlocking

unlink

rxUnlink

unlinkBlocking

readSymlink

rxReadSymlink

readSymlinkBlocking

delete

rxDelete

deleteBlocking

deleteRecursive

rxDeleteRecursive

deleteRecursiveBlocking

mkdir

rxMkdir

mkdirBlocking

mkdir

rxMkdir

mkdirBlocking

mkdirs

rxMkdirs

mkdirsBlocking

mkdirs

rxMkdirs

mkdirsBlocking

readDir

rxReadDir

readDirBlocking

readDir