io.vertx.mutiny.core.file.FileSystem

All Implemented Interfaces:: MutinyDelegate

public class FileSystem extends Object implements MutinyDelegate

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 Mutiny-ified interface.

Author:

Tim Fox

See Also:

FileSystem

Field Summary

Fields

Modifier and Type

Field

Description

static final TypeArg<FileSystem>

__TYPE_ARG
Constructor Summary

Constructors

Constructor

Description

FileSystem(io.vertx.core.file.FileSystem delegate)

Create a new instance of FileSystem delegating to the given (non-null) instance of FileSystem.

FileSystem(Object delegate)
Method Summary

Modifier and Type

Method

Description

io.smallrye.mutiny.Uni<Void>

chmod(String path, String perms)

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

void

chmodAndAwait(String path, String perms)

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

FileSystem

chmodAndForget(String path, String perms)

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

FileSystem

chmodBlocking(String path, String perms)

Blocking version of chmod(String, String)

io.smallrye.mutiny.Uni<Void>

chmodRecursive(String path, String perms, String dirPerms)

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

void

chmodRecursiveAndAwait(String path, String perms, String dirPerms)

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

FileSystem

chmodRecursiveAndForget(String path, String perms, String dirPerms)

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

FileSystem

chmodRecursiveBlocking(String path, String perms, String dirPerms)

Blocking version of chmodRecursive(String, String, String)

io.smallrye.mutiny.Uni<Void>

chown(String path, String user, String group)

Change the ownership on the file represented by path to user and {code group}, asynchronously.

void

chownAndAwait(String path, String user, String group)

Change the ownership on the file represented by path to user and {code group}, asynchronously.

FileSystem

chownAndForget(String path, String user, String group)

Change the ownership on the file represented by path to user and {code group}, asynchronously.

FileSystem

chownBlocking(String path, String user, String group)

Blocking version of chown(String, String, String)

io.smallrye.mutiny.Uni<Void>

copy(String from, String to)

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

io.smallrye.mutiny.Uni<Void>

copy(String from, String to, io.vertx.core.file.CopyOptions options)

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

void

copyAndAwait(String from, String to)

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

void

copyAndAwait(String from, String to, io.vertx.core.file.CopyOptions options)

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

FileSystem

copyAndForget(String from, String to)

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

FileSystem

copyAndForget(String from, String to, io.vertx.core.file.CopyOptions options)

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

FileSystem

copyBlocking(String from, String to)

Blocking version of copy(String, String)

io.smallrye.mutiny.Uni<Void>

copyRecursive(String from, String to, boolean recursive)

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

void

copyRecursiveAndAwait(String from, String to, boolean recursive)

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

FileSystem

copyRecursiveAndForget(String from, String to, boolean recursive)

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

FileSystem

copyRecursiveBlocking(String from, String to, boolean recursive)

Blocking version of copyRecursive(String, String, boolean)

io.smallrye.mutiny.Uni<Void>

createFile(String path)

Creates an empty file with the specified path, asynchronously.

io.smallrye.mutiny.Uni<Void>

createFile(String path, String perms)

Creates an empty file with the specified path and permissions perms, asynchronously.

void

createFileAndAwait(String path)

Creates an empty file with the specified path, asynchronously.

void

createFileAndAwait(String path, String perms)

Creates an empty file with the specified path and permissions perms, asynchronously.

FileSystem

createFileAndForget(String path)

Creates an empty file with the specified path, asynchronously.

FileSystem

createFileAndForget(String path, String perms)

Creates an empty file with the specified path and permissions perms, asynchronously.

FileSystem

createFileBlocking(String path)

Blocking version of createFile(String)

FileSystem

createFileBlocking(String path, String perms)

Blocking version of createFile(String, String)

io.smallrye.mutiny.Uni<String>

createTempDirectory(String prefix)

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

io.smallrye.mutiny.Uni<String>

createTempDirectory(String prefix, String perms)

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

io.smallrye.mutiny.Uni<String>

createTempDirectory(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.

String

createTempDirectoryAndAwait(String prefix)

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

String

createTempDirectoryAndAwait(String prefix, String perms)

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

String

createTempDirectoryAndAwait(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.

FileSystem

createTempDirectoryAndForget(String prefix)

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

FileSystem

createTempDirectoryAndForget(String prefix, String perms)

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

FileSystem

createTempDirectoryAndForget(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.

String

createTempDirectoryBlocking(String prefix)

Blocking version of createTempDirectory(String)

String

createTempDirectoryBlocking(String prefix, String perms)

Blocking version of createTempDirectory(String, String)

String

createTempDirectoryBlocking(String dir, String prefix, String perms)

Blocking version of createTempDirectory(String, String, String)

io.smallrye.mutiny.Uni<String>

createTempFile(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.

io.smallrye.mutiny.Uni<String>

createTempFile(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.

io.smallrye.mutiny.Uni<String>

createTempFile(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.

String

createTempFileAndAwait(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.

String

createTempFileAndAwait(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.

String

createTempFileAndAwait(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.

FileSystem

createTempFileAndForget(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.

FileSystem

createTempFileAndForget(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.

FileSystem

createTempFileAndForget(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.

String

createTempFileBlocking(String prefix, String suffix)

Blocking version of createTempFile(String, String)

String

createTempFileBlocking(String prefix, String suffix, String perms)

Blocking version of createTempFile(String, String, String)

String

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

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

io.smallrye.mutiny.Uni<Void>

delete(String path)

Deletes the file represented by the specified path, asynchronously.

void

deleteAndAwait(String path)

Deletes the file represented by the specified path, asynchronously.

FileSystem

deleteAndForget(String path)

Deletes the file represented by the specified path, asynchronously.

FileSystem

deleteBlocking(String path)

Blocking version of delete(String)

io.smallrye.mutiny.Uni<Void>

deleteRecursive(String path)

Deletes the file represented by the specified path, asynchronously.

void

deleteRecursiveAndAwait(String path)

Deletes the file represented by the specified path, asynchronously.

FileSystem

deleteRecursiveAndForget(String path)

Deletes the file represented by the specified path, asynchronously.

FileSystem

deleteRecursiveBlocking(String path)

Blocking version of deleteRecursive(String)

boolean

equals(Object o)

io.smallrye.mutiny.Uni<Boolean>

exists(String path)

Determines whether the file as specified by the path path exists, asynchronously.

Boolean

existsAndAwait(String path)

Determines whether the file as specified by the path path exists, asynchronously.

FileSystem

existsAndForget(String path)

Determines whether the file as specified by the path path exists, asynchronously.

boolean

existsBlocking(String path)

Blocking version of exists(String)

io.smallrye.mutiny.Uni<io.vertx.core.file.FileSystemProps>

fsProps(String path)

Returns properties of the file-system being used by the specified path, asynchronously.

io.vertx.core.file.FileSystemProps

fsPropsAndAwait(String path)

Returns properties of the file-system being used by the specified path, asynchronously.

FileSystem

fsPropsAndForget(String path)

Returns properties of the file-system being used by the specified path, asynchronously.

io.vertx.core.file.FileSystemProps

fsPropsBlocking(String path)

Blocking version of fsProps(String)

io.vertx.core.file.FileSystem

getDelegate()

Get the delegate instance.

int

hashCode()

io.smallrye.mutiny.Uni<Void>

link(String link, String existing)

Create a hard link on the file system from link to existing, asynchronously.

void

linkAndAwait(String link, String existing)

Create a hard link on the file system from link to existing, asynchronously.

FileSystem

linkAndForget(String link, String existing)

Create a hard link on the file system from link to existing, asynchronously.

FileSystem

linkBlocking(String link, String existing)

Blocking version of link(String, String)

io.smallrye.mutiny.Uni<io.vertx.core.file.FileProps>

lprops(String path)

Obtain properties for the link represented by path, asynchronously.

io.vertx.core.file.FileProps

lpropsAndAwait(String path)

Obtain properties for the link represented by path, asynchronously.

FileSystem

lpropsAndForget(String path)

Obtain properties for the link represented by path, asynchronously.

io.vertx.core.file.FileProps

lpropsBlocking(String path)

Blocking version of lprops(String)

io.smallrye.mutiny.Uni<Void>

mkdir(String path)

Create the directory represented by path, asynchronously.

io.smallrye.mutiny.Uni<Void>

mkdir(String path, String perms)

Create the directory represented by path, asynchronously.

void

mkdirAndAwait(String path)

Create the directory represented by path, asynchronously.

void

mkdirAndAwait(String path, String perms)

Create the directory represented by path, asynchronously.

FileSystem

mkdirAndForget(String path)

Create the directory represented by path, asynchronously.

FileSystem

mkdirAndForget(String path, String perms)

Create the directory represented by path, asynchronously.

FileSystem

mkdirBlocking(String path)

Blocking version of mkdir(String)

FileSystem

mkdirBlocking(String path, String perms)

Blocking version of mkdir(String, String)

io.smallrye.mutiny.Uni<Void>

mkdirs(String path)

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

io.smallrye.mutiny.Uni<Void>

mkdirs(String path, String perms)

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

void

mkdirsAndAwait(String path)

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

void

mkdirsAndAwait(String path, String perms)

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

FileSystem

mkdirsAndForget(String path)

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

FileSystem

mkdirsAndForget(String path, String perms)

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

FileSystem

mkdirsBlocking(String path)

Blocking version of mkdirs(String)

FileSystem

mkdirsBlocking(String path, String perms)

Blocking version of mkdirs(String, String)

io.smallrye.mutiny.Uni<Void>

move(String from, String to)

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

io.smallrye.mutiny.Uni<Void>

move(String from, String to, io.vertx.core.file.CopyOptions options)

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

void

moveAndAwait(String from, String to)

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

void

moveAndAwait(String from, String to, io.vertx.core.file.CopyOptions options)

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

FileSystem

moveAndForget(String from, String to)

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

FileSystem

moveAndForget(String from, String to, io.vertx.core.file.CopyOptions options)

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

FileSystem

moveBlocking(String from, String to)

Blocking version of move(String, String)

static FileSystem

newInstance(io.vertx.core.file.FileSystem delegate)

Creates a new instance of the FileSystem.

io.smallrye.mutiny.Uni<AsyncFile>

open(String path, io.vertx.core.file.OpenOptions options)

Open the file represented by path, asynchronously.

AsyncFile

openAndAwait(String path, io.vertx.core.file.OpenOptions options)

Open the file represented by path, asynchronously.

FileSystem

openAndForget(String path, io.vertx.core.file.OpenOptions options)

Open the file represented by path, asynchronously.

AsyncFile

openBlocking(String path, io.vertx.core.file.OpenOptions options)

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

io.smallrye.mutiny.Uni<io.vertx.core.file.FileProps>

props(String path)

Obtain properties for the file represented by path, asynchronously.

io.vertx.core.file.FileProps

propsAndAwait(String path)

Obtain properties for the file represented by path, asynchronously.

FileSystem

propsAndForget(String path)

Obtain properties for the file represented by path, asynchronously.

io.vertx.core.file.FileProps

propsBlocking(String path)

Blocking version of props(String)

io.smallrye.mutiny.Uni<List<String>>

readDir(String path)

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

io.smallrye.mutiny.Uni<List<String>>

readDir(String path, String filter)

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

List<String>

readDirAndAwait(String path)

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

List<String>

readDirAndAwait(String path, String filter)

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

FileSystem

readDirAndForget(String path)

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

FileSystem

readDirAndForget(String path, String filter)

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

List<String>

readDirBlocking(String path)

Blocking version of readDir(String)

List<String>

readDirBlocking(String path, String filter)

Blocking version of readDir(String, String)

io.smallrye.mutiny.Uni<io.vertx.core.buffer.Buffer>

readFile(String path)

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

io.vertx.core.buffer.Buffer

readFileAndAwait(String path)

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

FileSystem

readFileAndForget(String path)

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

io.vertx.core.buffer.Buffer

readFileBlocking(String path)

Blocking version of readFile(String)

io.smallrye.mutiny.Uni<String>

readSymlink(String link)

Returns the path representing the file that the symbolic link specified by link points to, asynchronously.

String

readSymlinkAndAwait(String link)

Returns the path representing the file that the symbolic link specified by link points to, asynchronously.

FileSystem

readSymlinkAndForget(String link)

Returns the path representing the file that the symbolic link specified by link points to, asynchronously.

String

readSymlinkBlocking(String link)

Blocking version of readSymlink(String)

io.smallrye.mutiny.Uni<Void>

symlink(String link, String existing)

Create a symbolic link on the file system from link to existing, asynchronously.

void

symlinkAndAwait(String link, String existing)

Create a symbolic link on the file system from link to existing, asynchronously.

FileSystem

symlinkAndForget(String link, String existing)

Create a symbolic link on the file system from link to existing, asynchronously.

FileSystem

symlinkBlocking(String link, String existing)

Blocking version of link(String, String)

String

toString()

io.smallrye.mutiny.Uni<Void>

truncate(String path, long len)

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

void

truncateAndAwait(String path, long len)

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

FileSystem

truncateAndForget(String path, long len)

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

FileSystem

truncateBlocking(String path, long len)

Blocking version of truncate(String, long)

io.smallrye.mutiny.Uni<Void>

unlink(String link)

Unlinks the link on the file system represented by the path link, asynchronously.

void

unlinkAndAwait(String link)

Unlinks the link on the file system represented by the path link, asynchronously.

FileSystem

unlinkAndForget(String link)

Unlinks the link on the file system represented by the path link, asynchronously.

FileSystem

unlinkBlocking(String link)

Blocking version of unlink(String)

io.smallrye.mutiny.Uni<Void>

writeFile(String path, io.vertx.core.buffer.Buffer data)

Creates the file, and writes the specified Buffer data to the file represented by the path path, asynchronously.

void

writeFileAndAwait(String path, io.vertx.core.buffer.Buffer data)

Creates the file, and writes the specified Buffer data to the file represented by the path path, asynchronously.

FileSystem

writeFileAndForget(String path, io.vertx.core.buffer.Buffer data)

Creates the file, and writes the specified Buffer data to the file represented by the path path, asynchronously.

FileSystem

writeFileBlocking(String path, io.vertx.core.buffer.Buffer data)

Blocking version of writeFile(String, Buffer)

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

Field Details
- __TYPE_ARG
  
  public static final TypeArg<FileSystem> __TYPE_ARG
Constructor Details
- FileSystem
  
  public FileSystem(io.vertx.core.file.FileSystem delegate)
  
  Create a new instance of FileSystem delegating to the given (non-null) instance of FileSystem.
- FileSystem
  
  public FileSystem(Object delegate)
Method Details
- getDelegate
  
  public io.vertx.core.file.FileSystem getDelegate()
  
  Get the delegate instance.
  This method returns the instance on which this shim is delegating the calls. And so, give you access to the bare API.
  
  Specified by:
  
  getDelegate in interface MutinyDelegate
  
  Returns:
  
  the delegate instance
- copy
  
  @CheckReturnValue public io.smallrye.mutiny.Uni<Void> copy(String from, String to)
  
  Copy a file from the path from to path to, asynchronously.
  The copy will fail if the destination already exists.
  Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.
  
  Don't forget to subscribe on it to trigger the operation.
  Parameters:
  
  from - the path to copy from
  
  to - the path to copy to
  
  Returns:
  
  A Uni representing the asynchronous result of this operation.
  
  See Also:
  
  FileSystem.copy(String, String)
- copyAndAwait
  
  public void copyAndAwait(String from, String to)
  
  Copy a file from the path from to path to, asynchronously.
  The copy will fail if the destination already exists.
  Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
  Parameters:
  
  from - the path to copy from
  
  to - the path to copy to
  
  See Also:
  
  FileSystem.copy(String, String)
- copyAndForget
  
  public FileSystem copyAndForget(String from, String to)
  
  Copy a file from the path from to path to, asynchronously.
  The copy will fail if the destination already exists.
  Unlike the bare Vert.x variant, this method ignores the Void result or any failure.
  Parameters:
  
  from - the path to copy from
  
  to - the path to copy to
  
  Returns:
  
  The current instance to chain operations if needed.
  
  See Also:
  
  FileSystem.copy(String, String)
- copy
  
  @CheckReturnValue public io.smallrye.mutiny.Uni<Void> copy(String from, String to, io.vertx.core.file.CopyOptions options)
  
  Copy a file from the path from to path to, asynchronously.
  Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.
  
  Don't forget to subscribe on it to trigger the operation.
  Parameters:
  
  from - the path to copy from
  
  to - the path to copy to
  
  options - options describing how the file should be copied
  
  Returns:
  
  A Uni representing the asynchronous result of this operation.
  
  See Also:
  
  FileSystem.copy(String, String, CopyOptions)
- copyAndAwait
  
  public void copyAndAwait(String from, String to, io.vertx.core.file.CopyOptions options)
  
  Copy a file from the path from to path to, asynchronously.
  Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
  Parameters:
  
  from - the path to copy from
  
  to - the path to copy to
  
  options - options describing how the file should be copied
  
  See Also:
  
  FileSystem.copy(String, String, CopyOptions)
- copyAndForget
  
  public FileSystem copyAndForget(String from, String to, io.vertx.core.file.CopyOptions options)
  
  Copy a file from the path from to path to, asynchronously.
  Unlike the bare Vert.x variant, this method ignores the Void result or any failure.
  Parameters:
  
  from - the path to copy from
  
  to - the path to copy to
  
  options - options describing how the file should be copied
  
  Returns:
  
  The current instance to chain operations if needed.
  
  See Also:
  
  FileSystem.copy(String, String, CopyOptions)
- copyRecursive
  
  @CheckReturnValue public io.smallrye.mutiny.Uni<Void> copyRecursive(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.
  Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.
  
  Don't forget to subscribe on it to trigger the operation.
  Parameters:
  
  from - the path to copy from
  
  to - the path to copy to
  
  recursive -
  
  Returns:
  
  A Uni representing the asynchronous result of this operation.
  
  See Also:
  
  FileSystem.copyRecursive(String, String, boolean)
- copyRecursiveAndAwait
  
  public void copyRecursiveAndAwait(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.
  Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
  Parameters:
  
  from - the path to copy from
  
  to - the path to copy to
  
  recursive -
  
  See Also:
  
  FileSystem.copyRecursive(String, String, boolean)
- copyRecursiveAndForget
  
  public FileSystem copyRecursiveAndForget(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.
  Unlike the bare Vert.x variant, this method ignores the Void result or any failure.
  Parameters:
  
  from - the path to copy from
  
  to - the path to copy to
  
  recursive -
  
  Returns:
  
  The current instance to chain operations if needed.
  
  See Also:
  
  FileSystem.copyRecursive(String, String, boolean)
- move
  
  @CheckReturnValue public io.smallrye.mutiny.Uni<Void> move(String from, String to)
  
  Move a file from the path from to path to, asynchronously.
  The move will fail if the destination already exists.
  Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.
  
  Don't forget to subscribe on it to trigger the operation.
  Parameters:
  
  from - the path to copy from
  
  to - the path to copy to
  
  Returns:
  
  A Uni representing the asynchronous result of this operation.
  
  See Also:
  
  FileSystem.move(String, String)
- moveAndAwait
  
  public void moveAndAwait(String from, String to)
  
  Move a file from the path from to path to, asynchronously.
  The move will fail if the destination already exists.
  Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
  Parameters:
  
  from - the path to copy from
  
  to - the path to copy to
  
  See Also:
  
  FileSystem.move(String, String)
- moveAndForget
  
  public FileSystem moveAndForget(String from, String to)
  
  Move a file from the path from to path to, asynchronously.
  The move will fail if the destination already exists.
  Unlike the bare Vert.x variant, this method ignores the Void result or any failure.
  Parameters:
  
  from - the path to copy from
  
  to - the path to copy to
  
  Returns:
  
  The current instance to chain operations if needed.
  
  See Also:
  
  FileSystem.move(String, String)
- move
  
  @CheckReturnValue public io.smallrye.mutiny.Uni<Void> move(String from, String to, io.vertx.core.file.CopyOptions options)
  
  Move a file from the path from to path to, asynchronously.
  Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.
  
  Don't forget to subscribe on it to trigger the operation.
  Parameters:
  
  from - the path to copy from
  
  to - the path to copy to
  
  options - options describing how the file should be copied
  
  Returns:
  
  A Uni representing the asynchronous result of this operation.
  
  See Also:
  
  FileSystem.move(String, String, CopyOptions)
- moveAndAwait
  
  public void moveAndAwait(String from, String to, io.vertx.core.file.CopyOptions options)
  
  Move a file from the path from to path to, asynchronously.
  Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
  Parameters:
  
  from - the path to copy from
  
  to - the path to copy to
  
  options - options describing how the file should be copied
  
  See Also:
  
  FileSystem.move(String, String, CopyOptions)
- moveAndForget
  
  public FileSystem moveAndForget(String from, String to, io.vertx.core.file.CopyOptions options)
  
  Move a file from the path from to path to, asynchronously.
  Unlike the bare Vert.x variant, this method ignores the Void result or any failure.
  Parameters:
  
  from - the path to copy from
  
  to - the path to copy to
  
  options - options describing how the file should be copied
  
  Returns:
  
  The current instance to chain operations if needed.
  
  See Also:
  
  FileSystem.move(String, String, CopyOptions)
- truncate
  
  @CheckReturnValue public io.smallrye.mutiny.Uni<Void> truncate(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.
  Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.
  
  Don't forget to subscribe on it to trigger the operation.
  Parameters:
  
  path - the path to the file
  
  len - the length to truncate it to
  
  Returns:
  
  A Uni representing the asynchronous result of this operation.
  
  See Also:
  
  FileSystem.truncate(String, long)
- truncateAndAwait
  
  public void truncateAndAwait(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.
  Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
  Parameters:
  
  path - the path to the file
  
  len - the length to truncate it to
  
  See Also:
  
  FileSystem.truncate(String, long)
- truncateAndForget
  
  public FileSystem truncateAndForget(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.
  Unlike the bare Vert.x variant, this method ignores the Void result or any failure.
  Parameters:
  
  path - the path to the file
  
  len - the length to truncate it to
  
  Returns:
  
  The current instance to chain operations if needed.
  
  See Also:
  
  FileSystem.truncate(String, long)
- chmod
  
  @CheckReturnValue public io.smallrye.mutiny.Uni<Void> chmod(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.
  Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.
  
  Don't forget to subscribe on it to trigger the operation.
  Parameters:
  
  path - the path to the file
  
  perms - the permissions string
  
  Returns:
  
  A Uni representing the asynchronous result of this operation.
  
  See Also:
  
  FileSystem.chmod(String, String)
- chmodAndAwait
  
  public void chmodAndAwait(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.
  Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
  Parameters:
  
  path - the path to the file
  
  perms - the permissions string
  
  See Also:
  
  FileSystem.chmod(String, String)
- chmodAndForget
  
  public FileSystem chmodAndForget(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.
  Unlike the bare Vert.x variant, this method ignores the Void result or any failure.
  Parameters:
  
  path - the path to the file
  
  perms - the permissions string
  
  Returns:
  
  The current instance to chain operations if needed.
  
  See Also:
  
  FileSystem.chmod(String, String)
- chmodRecursive
  
  @CheckReturnValue public io.smallrye.mutiny.Uni<Void> chmodRecursive(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.
  Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.
  
  Don't forget to subscribe on it to trigger the operation.
  Parameters:
  
  path - the path to the file
  
  perms - the permissions string
  
  dirPerms - the directory permissions
  
  Returns:
  
  A Uni representing the asynchronous result of this operation.
  
  See Also:
  
  FileSystem.chmodRecursive(String, String, String)
- chmodRecursiveAndAwait
  
  public void chmodRecursiveAndAwait(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.
  Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
  Parameters:
  
  path - the path to the file
  
  perms - the permissions string
  
  dirPerms - the directory permissions
  
  See Also:
  
  FileSystem.chmodRecursive(String, String, String)
- chmodRecursiveAndForget
  
  public FileSystem chmodRecursiveAndForget(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.
  Unlike the bare Vert.x variant, this method ignores the Void result or any failure.
  Parameters:
  
  path - the path to the file
  
  perms - the permissions string
  
  dirPerms - the directory permissions
  
  Returns:
  
  The current instance to chain operations if needed.
  
  See Also:
  
  FileSystem.chmodRecursive(String, String, String)
- chown
  
  @CheckReturnValue public io.smallrye.mutiny.Uni<Void> chown(String path, String user, String group)
  
  Change the ownership on the file represented by path to user and {code group}, asynchronously.
  Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.
  
  Don't forget to subscribe on it to trigger the operation.
  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 Uni representing the asynchronous result of this operation.
  
  See Also:
  
  FileSystem.chown(String, String, String)
- chownAndAwait
  
  public void chownAndAwait(String path, String user, String group)
  
  Change the ownership on the file represented by path to user and {code group}, asynchronously.
  Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
  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
  
  See Also:
  
  FileSystem.chown(String, String, String)
- chownAndForget
  
  public FileSystem chownAndForget(String path, String user, String group)
  
  Change the ownership on the file represented by path to user and {code group}, asynchronously.
  Unlike the bare Vert.x variant, this method ignores the Void result or any failure.
  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:
  
  The current instance to chain operations if needed.
  
  See Also:
  
  FileSystem.chown(String, String, String)
- props
  
  @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.core.file.FileProps> props(String path)
  
  Obtain properties for the file represented by path, asynchronously.
  If the file is a link, the link will be followed.
  Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.
  
  Don't forget to subscribe on it to trigger the operation.
  Parameters:
  
  path - the path to the file
  
  Returns:
  
  A Uni representing the asynchronous result of this operation.
  
  See Also:
  
  FileSystem.props(String)
- propsAndAwait
  
  public io.vertx.core.file.FileProps propsAndAwait(String path)
  
  Obtain properties for the file represented by path, asynchronously.
  If the file is a link, the link will be followed.
  Unlike the bare Vert.x variant, this method returns a FileProps. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
  Parameters:
  
  path - the path to the file
  
  Returns:
  
  The operation result
  
  See Also:
  
  FileSystem.props(String)
- propsAndForget
  
  public FileSystem propsAndForget(String path)
  
  Obtain properties for the file represented by path, asynchronously.
  If the file is a link, the link will be followed.
  Unlike the bare Vert.x variant, this method ignores the FileProps result or any failure.
  Parameters:
  
  path - the path to the file
  
  Returns:
  
  The current instance to chain operations if needed.
  
  See Also:
  
  FileSystem.props(String)
- lprops
  
  @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.core.file.FileProps> lprops(String path)
  
  Obtain properties for the link represented by path, asynchronously.
  The link will not be followed.
  Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.
  
  Don't forget to subscribe on it to trigger the operation.
  Parameters:
  
  path - the path to the file
  
  Returns:
  
  A Uni representing the asynchronous result of this operation.
  
  See Also:
  
  FileSystem.lprops(String)
- lpropsAndAwait
  
  public io.vertx.core.file.FileProps lpropsAndAwait(String path)
  
  Obtain properties for the link represented by path, asynchronously.
  The link will not be followed.
  Unlike the bare Vert.x variant, this method returns a FileProps. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
  Parameters:
  
  path - the path to the file
  
  Returns:
  
  The operation result
  
  See Also:
  
  FileSystem.lprops(String)
- lpropsAndForget
  
  public FileSystem lpropsAndForget(String path)
  
  Obtain properties for the link represented by path, asynchronously.
  The link will not be followed.
  Unlike the bare Vert.x variant, this method ignores the FileProps result or any failure.
  Parameters:
  
  path - the path to the file
  
  Returns:
  
  The current instance to chain operations if needed.
  
  See Also:
  
  FileSystem.lprops(String)
- link
  
  @CheckReturnValue public io.smallrye.mutiny.Uni<Void> link(String link, String existing)
  
  Create a hard link on the file system from link to existing, asynchronously.
  Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.
  
  Don't forget to subscribe on it to trigger the operation.
  Parameters:
  
  link - the link
  
  existing - the link destination
  
  Returns:
  
  A Uni representing the asynchronous result of this operation.
  
  See Also:
  
  FileSystem.link(String, String)
- linkAndAwait
  
  public void linkAndAwait(String link, String existing)
  
  Create a hard link on the file system from link to existing, asynchronously.
  Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
  Parameters:
  
  link - the link
  
  existing - the link destination
  
  See Also:
  
  FileSystem.link(String, String)
- linkAndForget
  
  public FileSystem linkAndForget(String link, String existing)
  
  Create a hard link on the file system from link to existing, asynchronously.
  Unlike the bare Vert.x variant, this method ignores the Void result or any failure.
  Parameters:
  
  link - the link
  
  existing - the link destination
  
  Returns:
  
  The current instance to chain operations if needed.
  
  See Also:
  
  FileSystem.link(String, String)
- symlink
  
  @CheckReturnValue public io.smallrye.mutiny.Uni<Void> symlink(String link, String existing)
  
  Create a symbolic link on the file system from link to existing, asynchronously.
  Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.
  
  Don't forget to subscribe on it to trigger the operation.
  Parameters:
  
  link - the link
  
  existing - the link destination
  
  Returns:
  
  A Uni representing the asynchronous result of this operation.
  
  See Also:
  
  FileSystem.symlink(String, String)
- symlinkAndAwait
  
  public void symlinkAndAwait(String link, String existing)
  
  Create a symbolic link on the file system from link to existing, asynchronously.
  Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
  Parameters:
  
  link - the link
  
  existing - the link destination
  
  See Also:
  
  FileSystem.symlink(String, String)
- symlinkAndForget
  
  public FileSystem symlinkAndForget(String link, String existing)
  
  Create a symbolic link on the file system from link to existing, asynchronously.
  Unlike the bare Vert.x variant, this method ignores the Void result or any failure.
  Parameters:
  
  link - the link
  
  existing - the link destination
  
  Returns:
  
  The current instance to chain operations if needed.
  
  See Also:
  
  FileSystem.symlink(String, String)
- unlink
  
  @CheckReturnValue public io.smallrye.mutiny.Uni<Void> unlink(String link)
  
  Unlinks the link on the file system represented by the path link, asynchronously.
  Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.
  
  Don't forget to subscribe on it to trigger the operation.
  Parameters:
  
  link - the link
  
  Returns:
  
  A Uni representing the asynchronous result of this operation.
  
  See Also:
  
  FileSystem.unlink(String)
- unlinkAndAwait
  
  public void unlinkAndAwait(String link)
  
  Unlinks the link on the file system represented by the path link, asynchronously.
  Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
  Parameters:
  
  link - the link
  
  See Also:
  
  FileSystem.unlink(String)
- unlinkAndForget
  
  public FileSystem unlinkAndForget(String link)
  
  Unlinks the link on the file system represented by the path link, asynchronously.
  Unlike the bare Vert.x variant, this method ignores the Void result or any failure.
  Parameters:
  
  link - the link
  
  Returns:
  
  The current instance to chain operations if needed.
  
  See Also:
  
  FileSystem.unlink(String)
- readSymlink
  
  @CheckReturnValue public io.smallrye.mutiny.Uni<String> readSymlink(String link)
  
  Returns the path representing the file that the symbolic link specified by link points to, asynchronously.
  Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.
  
  Don't forget to subscribe on it to trigger the operation.
  Parameters:
  
  link - the link
  
  Returns:
  
  A Uni representing the asynchronous result of this operation.
  
  See Also:
  
  FileSystem.readSymlink(String)
- readSymlinkAndAwait
  
  public String readSymlinkAndAwait(String link)
  
  Returns the path representing the file that the symbolic link specified by link points to, asynchronously.
  Unlike the bare Vert.x variant, this method returns a String. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
  Parameters:
  
  link - the link
  
  Returns:
  
  The operation result
  
  See Also:
  
  FileSystem.readSymlink(String)
- readSymlinkAndForget
  
  public FileSystem readSymlinkAndForget(String link)
  
  Returns the path representing the file that the symbolic link specified by link points to, asynchronously.
  Unlike the bare Vert.x variant, this method ignores the String result or any failure.
  Parameters:
  
  link - the link
  
  Returns:
  
  The current instance to chain operations if needed.
  
  See Also:
  
  FileSystem.readSymlink(String)
- delete
  
  @CheckReturnValue public io.smallrye.mutiny.Uni<Void> delete(String path)
  
  Deletes the file represented by the specified path, asynchronously.
  Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.
  
  Don't forget to subscribe on it to trigger the operation.
  Parameters:
  
  path - path to the file
  
  Returns:
  
  A Uni representing the asynchronous result of this operation.
  
  See Also:
  
  FileSystem.delete(String)
- deleteAndAwait
  
  public void deleteAndAwait(String path)
  
  Deletes the file represented by the specified path, asynchronously.
  Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
  Parameters:
  
  path - path to the file
  
  See Also:
  
  FileSystem.delete(String)
- deleteAndForget
  
  public FileSystem deleteAndForget(String path)
  
  Deletes the file represented by the specified path, asynchronously.
  Unlike the bare Vert.x variant, this method ignores the Void result or any failure.
  Parameters:
  
  path - path to the file
  
  Returns:
  
  The current instance to chain operations if needed.
  
  See Also:
  
  FileSystem.delete(String)
- deleteRecursive
  
  @CheckReturnValue public io.smallrye.mutiny.Uni<Void> deleteRecursive(String path)
  
  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.
  Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.
  
  Don't forget to subscribe on it to trigger the operation.
  Parameters:
  
  path - path to the file
  
  Returns:
  
  A Uni representing the asynchronous result of this operation.
  
  See Also:
  
  FileSystem.deleteRecursive(String)
- deleteRecursiveAndAwait
  
  public void deleteRecursiveAndAwait(String path)
  
  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.
  Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
  Parameters:
  
  path - path to the file
  
  See Also:
  
  FileSystem.deleteRecursive(String)
- deleteRecursiveAndForget
  
  public FileSystem deleteRecursiveAndForget(String path)
  
  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.
  Unlike the bare Vert.x variant, this method ignores the Void result or any failure.
  Parameters:
  
  path - path to the file
  
  Returns:
  
  The current instance to chain operations if needed.
  
  See Also:
  
  FileSystem.deleteRecursive(String)
- mkdir
  
  @CheckReturnValue public io.smallrye.mutiny.Uni<Void> mkdir(String path)
  
  Create the directory represented by path, asynchronously.
  The operation will fail if the directory already exists.
  Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.
  
  Don't forget to subscribe on it to trigger the operation.
  Parameters:
  
  path - path to the file
  
  Returns:
  
  A Uni representing the asynchronous result of this operation.
  
  See Also:
  
  FileSystem.mkdir(String)
- mkdirAndAwait
  
  public void mkdirAndAwait(String path)
  
  Create the directory represented by path, asynchronously.
  The operation will fail if the directory already exists.
  Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
  Parameters:
  
  path - path to the file
  
  See Also:
  
  FileSystem.mkdir(String)
- mkdirAndForget
  
  public FileSystem mkdirAndForget(String path)
  
  Create the directory represented by path, asynchronously.
  The operation will fail if the directory already exists.
  Unlike the bare Vert.x variant, this method ignores the Void result or any failure.
  Parameters:
  
  path - path to the file
  
  Returns:
  
  The current instance to chain operations if needed.
  
  See Also:
  
  FileSystem.mkdir(String)
- mkdir
  
  @CheckReturnValue public io.smallrye.mutiny.Uni<Void> mkdir(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.
  Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.
  
  Don't forget to subscribe on it to trigger the operation.
  Parameters:
  
  path - path to the file
  
  perms - the permissions string
  
  Returns:
  
  A Uni representing the asynchronous result of this operation.
  
  See Also:
  
  FileSystem.mkdir(String, String)
- mkdirAndAwait
  
  public void mkdirAndAwait(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.
  Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
  Parameters:
  
  path - path to the file
  
  perms - the permissions string
  
  See Also:
  
  FileSystem.mkdir(String, String)
- mkdirAndForget
  
  public FileSystem mkdirAndForget(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.
  Unlike the bare Vert.x variant, this method ignores the Void result or any failure.
  Parameters:
  
  path - path to the file
  
  perms - the permissions string
  
  Returns:
  
  The current instance to chain operations if needed.
  
  See Also:
  
  FileSystem.mkdir(String, String)
- mkdirs
  
  @CheckReturnValue public io.smallrye.mutiny.Uni<Void> mkdirs(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.
  Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.
  
  Don't forget to subscribe on it to trigger the operation.
  Parameters:
  
  path - path to the file
  
  Returns:
  
  A Uni representing the asynchronous result of this operation.
  
  See Also:
  
  FileSystem.mkdirs(String)
- mkdirsAndAwait
  
  public void mkdirsAndAwait(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.
  Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
  Parameters:
  
  path - path to the file
  
  See Also:
  
  FileSystem.mkdirs(String)
- mkdirsAndForget
  
  public FileSystem mkdirsAndForget(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.
  Unlike the bare Vert.x variant, this method ignores the Void result or any failure.
  Parameters:
  
  path - path to the file
  
  Returns:
  
  The current instance to chain operations if needed.
  
  See Also:
  
  FileSystem.mkdirs(String)
- mkdirs
  
  @CheckReturnValue public io.smallrye.mutiny.Uni<Void> mkdirs(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.
  Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.
  
  Don't forget to subscribe on it to trigger the operation.
  Parameters:
  
  path - path to the file
  
  perms - the permissions string
  
  Returns:
  
  A Uni representing the asynchronous result of this operation.
  
  See Also:
  
  FileSystem.mkdirs(String, String)
- mkdirsAndAwait
  
  public void mkdirsAndAwait(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.
  Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
  Parameters:
  
  path - path to the file
  
  perms - the permissions string
  
  See Also:
  
  FileSystem.mkdirs(String, String)
- mkdirsAndForget
  
  public FileSystem mkdirsAndForget(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.
  Unlike the bare Vert.x variant, this method ignores the Void result or any failure.
  Parameters:
  
  path - path to the file
  
  perms - the permissions string
  
  Returns:
  
  The current instance to chain operations if needed.
  
  See Also:
  
  FileSystem.mkdirs(String, String)
- readDir
  
  @CheckReturnValue public io.smallrye.mutiny.Uni<List<String>> readDir(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.
  Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.
  
  Don't forget to subscribe on it to trigger the operation.
  Parameters:
  
  path - path to the file
  
  Returns:
  
  A Uni representing the asynchronous result of this operation.
  
  See Also:
  
  FileSystem.readDir(String)
- readDirAndAwait
  
  public List<String> readDirAndAwait(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.
  Unlike the bare Vert.x variant, this method returns a List<String>. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
  Parameters:
  
  path - path to the file
  
  Returns:
  
  The operation result
  
  See Also:
  
  FileSystem.readDir(String)
- readDirAndForget
  
  public FileSystem readDirAndForget(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.
  Unlike the bare Vert.x variant, this method ignores the List<String> result or any failure.
  Parameters:
  
  path - path to the file
  
  Returns:
  
  The current instance to chain operations if needed.
  
  See Also:
  
  FileSystem.readDir(String)
- readDir
  
  @CheckReturnValue public io.smallrye.mutiny.Uni<List<String>> readDir(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.
  Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.
  
  Don't forget to subscribe on it to trigger the operation.
  Parameters:
  
  path - path to the directory
  
  filter - the filter expression
  
  Returns:
  
  A Uni representing the asynchronous result of this operation.
  
  See Also:
  
  FileSystem.readDir(String, String)
- readDirAndAwait
  
  public List<String> readDirAndAwait(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.
  Unlike the bare Vert.x variant, this method returns a List<String>. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
  Parameters:
  
  path - path to the directory
  
  filter - the filter expression
  
  Returns:
  
  The operation result
  
  See Also:
  
  FileSystem.readDir(String, String)
- readDirAndForget
  
  public FileSystem readDirAndForget(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.
  Unlike the bare Vert.x variant, this method ignores the List<String> result or any failure.
  Parameters:
  
  path - path to the directory
  
  filter - the filter expression
  
  Returns:
  
  The current instance to chain operations if needed.
  
  See Also:
  
  FileSystem.readDir(String, String)
- readFile
  
  @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.core.buffer.Buffer> readFile(String path)
  
  Reads the entire file as represented by the path path as a Buffer, asynchronously.
  Do not use this method to read very large files or you risk running out of available RAM.
  Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.
  
  Don't forget to subscribe on it to trigger the operation.
  Parameters:
  
  path - path to the file
  
  Returns:
  
  A Uni representing the asynchronous result of this operation.
  
  See Also:
  
  FileSystem.readFile(String)
- readFileAndAwait
  
  public io.vertx.core.buffer.Buffer readFileAndAwait(String path)
  
  Reads the entire file as represented by the path path as a Buffer, asynchronously.
  Do not use this method to read very large files or you risk running out of available RAM.
  Unlike the bare Vert.x variant, this method returns a Buffer. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
  Parameters:
  
  path - path to the file
  
  Returns:
  
  The operation result
  
  See Also:
  
  FileSystem.readFile(String)
- readFileAndForget
  
  public FileSystem readFileAndForget(String path)
  
  Reads the entire file as represented by the path path as a Buffer, asynchronously.
  Do not use this method to read very large files or you risk running out of available RAM.
  Unlike the bare Vert.x variant, this method ignores the Buffer result or any failure.
  Parameters:
  
  path - path to the file
  
  Returns:
  
  The current instance to chain operations if needed.
  
  See Also:
  
  FileSystem.readFile(String)
- writeFile
  
  @CheckReturnValue public io.smallrye.mutiny.Uni<Void> writeFile(String path, io.vertx.core.buffer.Buffer data)
  
  Creates the file, and writes the specified Buffer data to the file represented by the path path, asynchronously.
  Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.
  
  Don't forget to subscribe on it to trigger the operation.
  Parameters:
  
  path - path to the file
  
  Returns:
  
  A Uni representing the asynchronous result of this operation.
  
  See Also:
  
  FileSystem.writeFile(String, Buffer)
- writeFileAndAwait
  
  public void writeFileAndAwait(String path, io.vertx.core.buffer.Buffer data)
  
  Creates the file, and writes the specified Buffer data to the file represented by the path path, asynchronously.
  Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
  Parameters:
  
  path - path to the file
  
  See Also:
  
  FileSystem.writeFile(String, Buffer)
- writeFileAndForget
  
  public FileSystem writeFileAndForget(String path, io.vertx.core.buffer.Buffer data)
  
  Creates the file, and writes the specified Buffer data to the file represented by the path path, asynchronously.
  Unlike the bare Vert.x variant, this method ignores the Void result or any failure.
  Parameters:
  
  path - path to the file
  
  Returns:
  
  The current instance to chain operations if needed.
  
  See Also:
  
  FileSystem.writeFile(String, Buffer)
- open
  
  @CheckReturnValue public io.smallrye.mutiny.Uni<AsyncFile> open(String path, io.vertx.core.file.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.
  Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.
  
  Don't forget to subscribe on it to trigger the operation.
  Parameters:
  
  path - path to the file
  
  options - options describing how the file should be opened
  
  Returns:
  
  A Uni representing the asynchronous result of this operation.
  
  See Also:
  
  FileSystem.open(String, OpenOptions)
- openAndAwait
  
  public AsyncFile openAndAwait(String path, io.vertx.core.file.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.
  Unlike the bare Vert.x variant, this method returns a AsyncFile. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
  Parameters:
  
  path - path to the file
  
  options - options describing how the file should be opened
  
  Returns:
  
  The operation result
  
  See Also:
  
  FileSystem.open(String, OpenOptions)
- openAndForget
  
  public FileSystem openAndForget(String path, io.vertx.core.file.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.
  Unlike the bare Vert.x variant, this method ignores the AsyncFile result or any failure.
  Parameters:
  
  path - path to the file
  
  options - options describing how the file should be opened
  
  Returns:
  
  The current instance to chain operations if needed.
  
  See Also:
  
  FileSystem.open(String, OpenOptions)
- createFile
  
  @CheckReturnValue public io.smallrye.mutiny.Uni<Void> createFile(String path)
  
  Creates an empty file with the specified path, asynchronously.
  Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.
  
  Don't forget to subscribe on it to trigger the operation.
  Parameters:
  
  path - path to the file
  
  Returns:
  
  A Uni representing the asynchronous result of this operation.
  
  See Also:
  
  FileSystem.createFile(String)
- createFileAndAwait
  
  public void createFileAndAwait(String path)
  
  Creates an empty file with the specified path, asynchronously.
  Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
  Parameters:
  
  path - path to the file
  
  See Also:
  
  FileSystem.createFile(String)
- createFileAndForget
  
  public FileSystem createFileAndForget(String path)
  
  Creates an empty file with the specified path, asynchronously.
  Unlike the bare Vert.x variant, this method ignores the Void result or any failure.
  Parameters:
  
  path - path to the file
  
  Returns:
  
  The current instance to chain operations if needed.
  
  See Also:
  
  FileSystem.createFile(String)
- createFile
  
  @CheckReturnValue public io.smallrye.mutiny.Uni<Void> createFile(String path, String perms)
  
  Creates an empty file with the specified path and permissions perms, asynchronously.
  Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.
  
  Don't forget to subscribe on it to trigger the operation.
  Parameters:
  
  path - path to the file
  
  perms - the permissions string
  
  Returns:
  
  A Uni representing the asynchronous result of this operation.
  
  See Also:
  
  FileSystem.createFile(String, String)
- createFileAndAwait
  
  public void createFileAndAwait(String path, String perms)
  
  Creates an empty file with the specified path and permissions perms, asynchronously.
  Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
  Parameters:
  
  path - path to the file
  
  perms - the permissions string
  
  See Also:
  
  FileSystem.createFile(String, String)
- createFileAndForget
  
  public FileSystem createFileAndForget(String path, String perms)
  
  Creates an empty file with the specified path and permissions perms, asynchronously.
  Unlike the bare Vert.x variant, this method ignores the Void result or any failure.
  Parameters:
  
  path - path to the file
  
  perms - the permissions string
  
  Returns:
  
  The current instance to chain operations if needed.
  
  See Also:
  
  FileSystem.createFile(String, String)
- exists
  
  @CheckReturnValue public io.smallrye.mutiny.Uni<Boolean> exists(String path)
  
  Determines whether the file as specified by the path path exists, asynchronously.
  Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.
  
  Don't forget to subscribe on it to trigger the operation.
  Parameters:
  
  path - path to the file
  
  Returns:
  
  A Uni representing the asynchronous result of this operation.
  
  See Also:
  
  FileSystem.exists(String)
- existsAndAwait
  
  public Boolean existsAndAwait(String path)
  
  Determines whether the file as specified by the path path exists, asynchronously.
  Unlike the bare Vert.x variant, this method returns a Boolean. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
  Parameters:
  
  path - path to the file
  
  Returns:
  
  The operation result
  
  See Also:
  
  FileSystem.exists(String)
- existsAndForget
  
  public FileSystem existsAndForget(String path)
  
  Determines whether the file as specified by the path path exists, asynchronously.
  Unlike the bare Vert.x variant, this method ignores the Boolean result or any failure.
  Parameters:
  
  path - path to the file
  
  Returns:
  
  The current instance to chain operations if needed.
  
  See Also:
  
  FileSystem.exists(String)
- fsProps
  
  @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.core.file.FileSystemProps> fsProps(String path)
  
  Returns properties of the file-system being used by the specified path, asynchronously.
  Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.
  
  Don't forget to subscribe on it to trigger the operation.
  Parameters:
  
  path - path to anywhere on the filesystem
  
  Returns:
  
  A Uni representing the asynchronous result of this operation.
  
  See Also:
  
  FileSystem.fsProps(String)
- fsPropsAndAwait
  
  public io.vertx.core.file.FileSystemProps fsPropsAndAwait(String path)
  
  Returns properties of the file-system being used by the specified path, asynchronously.
  Unlike the bare Vert.x variant, this method returns a FileSystemProps. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
  Parameters:
  
  path - path to anywhere on the filesystem
  
  Returns:
  
  The operation result
  
  See Also:
  
  FileSystem.fsProps(String)
- fsPropsAndForget
  
  public FileSystem fsPropsAndForget(String path)
  
  Returns properties of the file-system being used by the specified path, asynchronously.
  Unlike the bare Vert.x variant, this method ignores the FileSystemProps result or any failure.
  Parameters:
  
  path - path to anywhere on the filesystem
  
  Returns:
  
  The current instance to chain operations if needed.
  
  See Also:
  
  FileSystem.fsProps(String)
- createTempDirectory
  
  @CheckReturnValue public io.smallrye.mutiny.Uni<String> createTempDirectory(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 shutdown-hook, or the File.deleteOnExit() mechanism may be used to delete the directory automatically.
  
  Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.
  
  Don't forget to subscribe on it to trigger the operation.
  Parameters:
  
  prefix - the prefix string to be used in generating the directory's name; may be null
  
  Returns:
  
  A Uni representing the asynchronous result of this operation.
  
  See Also:
  
  FileSystem.createTempDirectory(String)
- createTempDirectoryAndAwait
  
  public String createTempDirectoryAndAwait(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 shutdown-hook, or the File.deleteOnExit() mechanism may be used to delete the directory automatically.
  
  Unlike the bare Vert.x variant, this method returns a String. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
  Parameters:
  
  prefix - the prefix string to be used in generating the directory's name; may be null
  
  Returns:
  
  The operation result
  
  See Also:
  
  FileSystem.createTempDirectory(String)
- createTempDirectoryAndForget
  
  public FileSystem createTempDirectoryAndForget(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 shutdown-hook, or the File.deleteOnExit() mechanism may be used to delete the directory automatically.
  
  Unlike the bare Vert.x variant, this method ignores the String result or any failure.
  Parameters:
  
  prefix - the prefix string to be used in generating the directory's name; may be null
  
  Returns:
  
  The current instance to chain operations if needed.
  
  See Also:
  
  FileSystem.createTempDirectory(String)
- createTempDirectory
  
  @CheckReturnValue public io.smallrye.mutiny.Uni<String> createTempDirectory(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 shutdown-hook, or the File.deleteOnExit() mechanism may be used to delete the directory automatically.
  
  Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.
  
  Don't forget to subscribe on it to trigger the operation.
  Parameters:
  
  prefix - the prefix string to be used in generating the directory's name; may be null
  
  perms - the permissions string
  
  Returns:
  
  A Uni representing the asynchronous result of this operation.
  
  See Also:
  
  FileSystem.createTempDirectory(String, String)
- createTempDirectoryAndAwait
  
  public String createTempDirectoryAndAwait(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 shutdown-hook, or the File.deleteOnExit() mechanism may be used to delete the directory automatically.
  
  Unlike the bare Vert.x variant, this method returns a String. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
  Parameters:
  
  prefix - the prefix string to be used in generating the directory's name; may be null
  
  perms - the permissions string
  
  Returns:
  
  The operation result
  
  See Also:
  
  FileSystem.createTempDirectory(String, String)
- createTempDirectoryAndForget
  
  public FileSystem createTempDirectoryAndForget(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 shutdown-hook, or the File.deleteOnExit() mechanism may be used to delete the directory automatically.
  
  Unlike the bare Vert.x variant, this method ignores the String result or any failure.
  Parameters:
  
  prefix - the prefix string to be used in generating the directory's name; may be null
  
  perms - the permissions string
  
  Returns:
  
  The current instance to chain operations if needed.
  
  See Also:
  
  FileSystem.createTempDirectory(String, String)
- createTempDirectory
  
  @CheckReturnValue public io.smallrye.mutiny.Uni<String> createTempDirectory(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 shutdown-hook, or the File.deleteOnExit() mechanism may be used to delete the directory automatically.
  
  Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.
  
  Don't forget to subscribe on it to trigger the operation.
  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 Uni representing the asynchronous result of this operation.
  
  See Also:
  
  FileSystem.createTempDirectory(String, String, String)
- createTempDirectoryAndAwait
  
  public String createTempDirectoryAndAwait(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 shutdown-hook, or the File.deleteOnExit() mechanism may be used to delete the directory automatically.
  
  Unlike the bare Vert.x variant, this method returns a String. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
  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:
  
  The operation result
  
  See Also:
  
  FileSystem.createTempDirectory(String, String, String)
- createTempDirectoryAndForget
  
  public FileSystem createTempDirectoryAndForget(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 shutdown-hook, or the File.deleteOnExit() mechanism may be used to delete the directory automatically.
  
  Unlike the bare Vert.x variant, this method ignores the String result or any failure.
  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:
  
  The current instance to chain operations if needed.
  
  See Also:
  
  FileSystem.createTempDirectory(String, String, String)
- createTempFile
  
  @CheckReturnValue public io.smallrye.mutiny.Uni<String> createTempFile(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 shutdown-hook, or the File.deleteOnExit() mechanism may be used to delete the directory automatically.
  
  Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.
  
  Don't forget to subscribe on it to trigger the operation.
  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 Uni representing the asynchronous result of this operation.
  
  See Also:
  
  FileSystem.createTempFile(String, String)
- createTempFileAndAwait
  
  public String createTempFileAndAwait(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 shutdown-hook, or the File.deleteOnExit() mechanism may be used to delete the directory automatically.
  
  Unlike the bare Vert.x variant, this method returns a String. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
  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:
  
  The operation result
  
  See Also:
  
  FileSystem.createTempFile(String, String)
- createTempFileAndForget
  
  public FileSystem createTempFileAndForget(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 shutdown-hook, or the File.deleteOnExit() mechanism may be used to delete the directory automatically.
  
  Unlike the bare Vert.x variant, this method ignores the String result or any failure.
  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:
  
  The current instance to chain operations if needed.
  
  See Also:
  
  FileSystem.createTempFile(String, String)
- createTempFile
  
  @CheckReturnValue public io.smallrye.mutiny.Uni<String> createTempFile(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 shutdown-hook, or the File.deleteOnExit() mechanism may be used to delete the directory automatically.
  
  Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.
  
  Don't forget to subscribe on it to trigger the operation.
  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 Uni representing the asynchronous result of this operation.
  
  See Also:
  
  FileSystem.createTempFile(String, String, String)
- createTempFileAndAwait
  
  public String createTempFileAndAwait(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 shutdown-hook, or the File.deleteOnExit() mechanism may be used to delete the directory automatically.
  
  Unlike the bare Vert.x variant, this method returns a String. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
  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:
  
  The operation result
  
  See Also:
  
  FileSystem.createTempFile(String, String, String)
- createTempFileAndForget
  
  public FileSystem createTempFileAndForget(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 shutdown-hook, or the File.deleteOnExit() mechanism may be used to delete the directory automatically.
  
  Unlike the bare Vert.x variant, this method ignores the String result or any failure.
  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:
  
  The current instance to chain operations if needed.
  
  See Also:
  
  FileSystem.createTempFile(String, String, String)
- createTempFile
  
  @CheckReturnValue public io.smallrye.mutiny.Uni<String> createTempFile(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 shutdown-hook, or the File.deleteOnExit() mechanism may be used to delete the directory automatically.
  
  Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.
  
  Don't forget to subscribe on it to trigger the operation.
  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 Uni representing the asynchronous result of this operation.
  
  See Also:
  
  FileSystem.createTempFile(String, String, String, String)
- createTempFileAndAwait
  
  public String createTempFileAndAwait(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 shutdown-hook, or the File.deleteOnExit() mechanism may be used to delete the directory automatically.
  
  Unlike the bare Vert.x variant, this method returns a String. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
  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:
  
  The operation result
  
  See Also:
  
  FileSystem.createTempFile(String, String, String, String)
- createTempFileAndForget
  
  public FileSystem createTempFileAndForget(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 shutdown-hook, or the File.deleteOnExit() mechanism may be used to delete the directory automatically.
  
  Unlike the bare Vert.x variant, this method ignores the String result or any failure.
  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:
  
  The current instance to chain operations if needed.
  
  See Also:
  
  FileSystem.createTempFile(String, String, String, String)
- copyBlocking
  
  public FileSystem copyBlocking(String from, String to)
  
  Blocking version of copy(String, String)
- copyRecursiveBlocking
  
  public FileSystem copyRecursiveBlocking(String from, String to, boolean recursive)
  
  Blocking version of copyRecursive(String, String, boolean)
- moveBlocking
  
  public FileSystem moveBlocking(String from, String to)
  
  Blocking version of move(String, String)
- truncateBlocking
  
  public FileSystem truncateBlocking(String path, long len)
  
  Blocking version of truncate(String, long)
- chmodBlocking
  
  public FileSystem chmodBlocking(String path, String perms)
  
  Blocking version of chmod(String, String)
- chmodRecursiveBlocking
  
  public FileSystem chmodRecursiveBlocking(String path, String perms, String dirPerms)
  
  Blocking version of chmodRecursive(String, String, String)
- chownBlocking
  
  public FileSystem chownBlocking(String path, String user, String group)
  
  Blocking version of chown(String, String, String)
- propsBlocking
  
  public io.vertx.core.file.FileProps propsBlocking(String path)
  
  Blocking version of props(String)
- lpropsBlocking
  
  public io.vertx.core.file.FileProps lpropsBlocking(String path)
  
  Blocking version of lprops(String)
- linkBlocking
  
  public FileSystem linkBlocking(String link, String existing)
  
  Blocking version of link(String, String)
- symlinkBlocking
  
  public FileSystem symlinkBlocking(String link, String existing)
  
  Blocking version of link(String, String)
- unlinkBlocking
  
  public FileSystem unlinkBlocking(String link)
  
  Blocking version of unlink(String)
- readSymlinkBlocking
  
  public String readSymlinkBlocking(String link)
  
  Blocking version of readSymlink(String)
- deleteBlocking
  
  public FileSystem deleteBlocking(String path)
  
  Blocking version of delete(String)
- deleteRecursiveBlocking
  
  public FileSystem deleteRecursiveBlocking(String path)
  
  Blocking version of deleteRecursive(String)
- mkdirBlocking
  
  public FileSystem mkdirBlocking(String path)
  
  Blocking version of mkdir(String)
- mkdirBlocking
  
  public FileSystem mkdirBlocking(String path, String perms)
  
  Blocking version of mkdir(String, String)
- mkdirsBlocking
  
  public FileSystem mkdirsBlocking(String path)
  
  Blocking version of mkdirs(String)
- mkdirsBlocking
  
  public FileSystem mkdirsBlocking(String path, String perms)
  
  Blocking version of mkdirs(String, String)
- readDirBlocking
  
  public List<String> readDirBlocking(String path)
  
  Blocking version of readDir(String)
- readDirBlocking
  
  public List<String> readDirBlocking(String path, String filter)
  
  Blocking version of readDir(String, String)
- readFileBlocking
  
  public io.vertx.core.buffer.Buffer readFileBlocking(String path)
  
  Blocking version of readFile(String)
- writeFileBlocking
  
  public FileSystem writeFileBlocking(String path, io.vertx.core.buffer.Buffer data)
  
  Blocking version of writeFile(String, Buffer)
- openBlocking
  
  public AsyncFile openBlocking(String path, io.vertx.core.file.OpenOptions options)
  
  Blocking version of open(String, io.vertx.core.file.OpenOptions)
- createFileBlocking
  
  public FileSystem createFileBlocking(String path)
  
  Blocking version of createFile(String)
- createFileBlocking
  
  public FileSystem createFileBlocking(String path, String perms)
  
  Blocking version of createFile(String, String)
- existsBlocking
  
  public boolean existsBlocking(String path)
  
  Blocking version of exists(String)
- fsPropsBlocking
  
  public io.vertx.core.file.FileSystemProps fsPropsBlocking(String path)
  
  Blocking version of fsProps(String)
- createTempDirectoryBlocking
  
  public String createTempDirectoryBlocking(String prefix)
  
  Blocking version of createTempDirectory(String)
- createTempDirectoryBlocking
  
  public String createTempDirectoryBlocking(String prefix, String perms)
  
  Blocking version of createTempDirectory(String, String)
- createTempDirectoryBlocking
  
  public String createTempDirectoryBlocking(String dir, String prefix, String perms)
  
  Blocking version of createTempDirectory(String, String, String)
- createTempFileBlocking
  
  public String createTempFileBlocking(String prefix, String suffix)
  
  Blocking version of createTempFile(String, String)
- createTempFileBlocking
  
  public String createTempFileBlocking(String prefix, String suffix, String perms)
  
  Blocking version of createTempFile(String, String, String)
- createTempFileBlocking
  
  public String createTempFileBlocking(String dir, String prefix, String suffix, String perms)
  
  Blocking version of createTempFile(String, String, String, String)
- newInstance
  
  public static FileSystem newInstance(io.vertx.core.file.FileSystem delegate)
  
  Creates a new instance of the FileSystem.
- hashCode
  
  public int hashCode()
  
  Overrides:
  
  hashCode in class Object
- equals
  
  public boolean equals(Object o)
  
  Overrides:
  
  equals in class Object
- toString
  
  public String toString()
  
  Overrides:
  
  toString in class Object

Class FileSystem

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Details

__TYPE_ARG

Constructor Details

FileSystem

FileSystem

Method Details

getDelegate

copy

copyAndAwait

copyAndForget

copy

copyAndAwait

copyAndForget

copyRecursive

copyRecursiveAndAwait

copyRecursiveAndForget

move

moveAndAwait

moveAndForget

move

moveAndAwait

moveAndForget

truncate

truncateAndAwait

truncateAndForget

chmod

chmodAndAwait

chmodAndForget

chmodRecursive

chmodRecursiveAndAwait

chmodRecursiveAndForget

chown

chownAndAwait

chownAndForget

props

propsAndAwait

propsAndForget

lprops

lpropsAndAwait

lpropsAndForget

link

linkAndAwait

linkAndForget

symlink

symlinkAndAwait

symlinkAndForget

unlink

unlinkAndAwait

unlinkAndForget

readSymlink

readSymlinkAndAwait

readSymlinkAndForget

delete

deleteAndAwait

deleteAndForget

deleteRecursive

deleteRecursiveAndAwait

deleteRecursiveAndForget

mkdir

mkdirAndAwait

mkdirAndForget

mkdir

mkdirAndAwait

mkdirAndForget

mkdirs

mkdirsAndAwait

mkdirsAndForget

mkdirs

mkdirsAndAwait

mkdirsAndForget

readDir

readDirAndAwait

readDirAndForget

readDir

readDirAndAwait