public class FileSystem extends Object
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 theoriginal
non RX-ified interface using Vert.x codegen.Modifier and Type | Field and Description |
---|---|
static io.vertx.lang.rx.TypeArg<FileSystem> |
__TYPE_ARG |
Constructor and Description |
---|
FileSystem(FileSystem delegate) |
FileSystem(Object delegate) |
Modifier and Type | Method and Description |
---|---|
FileSystem |
chmod(String path,
String perms)
Change the permissions on the file represented by
path to perms , asynchronously. |
FileSystem |
chmod(String path,
String perms,
Handler<AsyncResult<Void>> handler)
Change the permissions on the file represented by
path to perms , asynchronously. |
FileSystem |
chmodBlocking(String path,
String perms)
Blocking version of
#chmod(String, String, Handler) |
FileSystem |
chmodRecursive(String path,
String perms,
String dirPerms)
Change the permissions on the file represented by
path to perms , asynchronously. |
FileSystem |
chmodRecursive(String path,
String perms,
String dirPerms,
Handler<AsyncResult<Void>> handler)
Change the permissions on the file represented by
path to perms , asynchronously. |
FileSystem |
chmodRecursiveBlocking(String path,
String perms,
String dirPerms)
|
FileSystem |
chown(String path,
String user,
String group)
Change the ownership on the file represented by
path to user and {code group}, asynchronously. |
FileSystem |
chown(String path,
String user,
String group,
Handler<AsyncResult<Void>> handler)
Change the ownership on the file represented by
path to user and {code group}, asynchronously. |
FileSystem |
chownBlocking(String path,
String user,
String group)
|
FileSystem |
copy(String from,
String to)
Copy a file from the path
from to path to , asynchronously. |
FileSystem |
copy(String from,
String to,
CopyOptions options)
Copy a file from the path
from to path to , asynchronously. |
FileSystem |
copy(String from,
String to,
CopyOptions options,
Handler<AsyncResult<Void>> handler)
Copy a file from the path
from to path to , asynchronously. |
FileSystem |
copy(String from,
String to,
Handler<AsyncResult<Void>> handler)
Copy a file from the path
from to path to , asynchronously. |
FileSystem |
copyBlocking(String from,
String to)
|
FileSystem |
copyRecursive(String from,
String to,
boolean recursive)
Copy a file from the path
from to path to , asynchronously. |
FileSystem |
copyRecursive(String from,
String to,
boolean recursive,
Handler<AsyncResult<Void>> handler)
Copy a file from the path
from to path to , asynchronously. |
FileSystem |
copyRecursiveBlocking(String from,
String to,
boolean recursive)
|
FileSystem |
createFile(String path)
Creates an empty file with the specified
path , asynchronously. |
FileSystem |
createFile(String path,
Handler<AsyncResult<Void>> handler)
Creates an empty file with the specified
path , asynchronously. |
FileSystem |
createFile(String path,
String perms)
Creates an empty file with the specified
path and permissions perms , asynchronously. |
FileSystem |
createFile(String path,
String perms,
Handler<AsyncResult<Void>> handler)
Creates an empty file with the specified
path and permissions perms , asynchronously. |
FileSystem |
createFileBlocking(String path)
|
FileSystem |
createFileBlocking(String path,
String perms)
|
FileSystem |
createTempDirectory(String prefix)
Creates a new directory in the default temporary-file directory, using the given
prefix to generate its name, asynchronously.
|
FileSystem |
createTempDirectory(String prefix,
Handler<AsyncResult<String>> handler)
Creates a new directory in the default temporary-file directory, using the given
prefix to generate its name, asynchronously.
|
FileSystem |
createTempDirectory(String prefix,
String perms)
Creates a new directory in the default temporary-file directory, using the given
prefix to generate its name, asynchronously.
|
FileSystem |
createTempDirectory(String prefix,
String perms,
Handler<AsyncResult<String>> handler)
Creates a new directory in the default temporary-file directory, using the given
prefix to generate its name, asynchronously.
|
FileSystem |
createTempDirectory(String dir,
String prefix,
String perms)
Creates a new directory in the directory provided by the path
path , using the given
prefix to generate its name, asynchronously. |
FileSystem |
createTempDirectory(String dir,
String prefix,
String perms,
Handler<AsyncResult<String>> handler)
Creates a new directory in the directory provided by the path
path , using the given
prefix to generate its name, asynchronously. |
String |
createTempDirectoryBlocking(String prefix)
|
String |
createTempDirectoryBlocking(String prefix,
String perms)
|
String |
createTempDirectoryBlocking(String dir,
String prefix,
String perms)
|
FileSystem |
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.
|
FileSystem |
createTempFile(String prefix,
String suffix,
Handler<AsyncResult<String>> handler)
Creates a new file in the default temporary-file directory, using the given
prefix and suffix to generate its name, asynchronously.
|
FileSystem |
createTempFile(String prefix,
String suffix,
String perms)
Creates a new file in the directory provided by the path
dir , using the given
prefix and suffix to generate its name, asynchronously. |
FileSystem |
createTempFile(String prefix,
String suffix,
String perms,
Handler<AsyncResult<String>> handler)
Creates a new file in the directory provided by the path
dir , using the given
prefix and suffix to generate its name, asynchronously. |
FileSystem |
createTempFile(String dir,
String prefix,
String suffix,
String perms)
Creates a new file in the directory provided by the path
dir , using the given
prefix and suffix to generate its name, asynchronously. |
FileSystem |
createTempFile(String dir,
String prefix,
String suffix,
String perms,
Handler<AsyncResult<String>> handler)
Creates a new file in the directory provided by the path
dir , using the given
prefix and suffix to generate its name, asynchronously. |
String |
createTempFileBlocking(String prefix,
String suffix)
|
String |
createTempFileBlocking(String prefix,
String suffix,
String perms)
|
String |
createTempFileBlocking(String dir,
String prefix,
String suffix,
String perms)
|
FileSystem |
delete(String path)
Deletes the file represented by the specified
path , asynchronously. |
FileSystem |
delete(String path,
Handler<AsyncResult<Void>> handler)
Deletes the file represented by the specified
path , asynchronously. |
FileSystem |
deleteBlocking(String path)
|
FileSystem |
deleteRecursive(String path,
boolean recursive)
Deletes the file represented by the specified
path , asynchronously. |
FileSystem |
deleteRecursive(String path,
boolean recursive,
Handler<AsyncResult<Void>> handler)
Deletes the file represented by the specified
path , asynchronously. |
FileSystem |
deleteRecursiveBlocking(String path,
boolean recursive)
|
boolean |
equals(Object o) |
FileSystem |
exists(String path)
Determines whether the file as specified by the path
path exists, asynchronously. |
FileSystem |
exists(String path,
Handler<AsyncResult<Boolean>> handler)
Determines whether the file as specified by the path
path exists, asynchronously. |
boolean |
existsBlocking(String path)
|
FileSystem |
fsProps(String path)
Returns properties of the file-system being used by the specified
path , asynchronously. |
FileSystem |
fsProps(String path,
Handler<AsyncResult<FileSystemProps>> handler)
Returns properties of the file-system being used by the specified
path , asynchronously. |
FileSystemProps |
fsPropsBlocking(String path)
|
FileSystem |
getDelegate() |
int |
hashCode() |
FileSystem |
link(String link,
String existing)
Create a hard link on the file system from
link to existing , asynchronously. |
FileSystem |
link(String link,
String existing,
Handler<AsyncResult<Void>> handler)
Create a hard link on the file system from
link to existing , asynchronously. |
FileSystem |
linkBlocking(String link,
String existing)
|
FileSystem |
lprops(String path)
Obtain properties for the link represented by
path , asynchronously. |
FileSystem |
lprops(String path,
Handler<AsyncResult<FileProps>> handler)
Obtain properties for the link represented by
path , asynchronously. |
FileProps |
lpropsBlocking(String path)
|
FileSystem |
mkdir(String path)
Create the directory represented by
path , asynchronously. |
FileSystem |
mkdir(String path,
Handler<AsyncResult<Void>> handler)
Create the directory represented by
path , asynchronously. |
FileSystem |
mkdir(String path,
String perms)
Create the directory represented by
path , asynchronously. |
FileSystem |
mkdir(String path,
String perms,
Handler<AsyncResult<Void>> handler)
Create the directory represented by
path , asynchronously. |
FileSystem |
mkdirBlocking(String path)
|
FileSystem |
mkdirBlocking(String path,
String perms)
|
FileSystem |
mkdirs(String path)
Create the directory represented by
path and any non existent parents, asynchronously. |
FileSystem |
mkdirs(String path,
Handler<AsyncResult<Void>> handler)
Create the directory represented by
path and any non existent parents, asynchronously. |
FileSystem |
mkdirs(String path,
String perms)
Create the directory represented by
path and any non existent parents, asynchronously. |
FileSystem |
mkdirs(String path,
String perms,
Handler<AsyncResult<Void>> handler)
Create the directory represented by
path and any non existent parents, asynchronously. |
FileSystem |
mkdirsBlocking(String path)
|
FileSystem |
mkdirsBlocking(String path,
String perms)
|
FileSystem |
move(String from,
String to)
Move a file from the path
from to path to , asynchronously. |
FileSystem |
move(String from,
String to,
CopyOptions options)
Move a file from the path
from to path to , asynchronously. |
FileSystem |
move(String from,
String to,
CopyOptions options,
Handler<AsyncResult<Void>> handler)
Move a file from the path
from to path to , asynchronously. |
FileSystem |
move(String from,
String to,
Handler<AsyncResult<Void>> handler)
Move a file from the path
from to path to , asynchronously. |
FileSystem |
moveBlocking(String from,
String to)
|
static FileSystem |
newInstance(FileSystem arg) |
FileSystem |
open(String path,
OpenOptions options)
Open the file represented by
path , asynchronously. |
FileSystem |
open(String path,
OpenOptions options,
Handler<AsyncResult<AsyncFile>> handler)
Open the file represented by
path , asynchronously. |
AsyncFile |
openBlocking(String path,
OpenOptions options)
|
FileSystem |
props(String path)
Obtain properties for the file represented by
path , asynchronously. |
FileSystem |
props(String path,
Handler<AsyncResult<FileProps>> handler)
Obtain properties for the file represented by
path , asynchronously. |
FileProps |
propsBlocking(String path)
|
FileSystem |
readDir(String path)
Read the contents of the directory specified by
path , asynchronously. |
FileSystem |
readDir(String path,
Handler<AsyncResult<List<String>>> handler)
Read the contents of the directory specified by
path , asynchronously. |
FileSystem |
readDir(String path,
String filter)
Read the contents of the directory specified by
path , asynchronously. |
FileSystem |
readDir(String path,
String filter,
Handler<AsyncResult<List<String>>> handler)
Read the contents of the directory specified by
path , asynchronously. |
List<String> |
readDirBlocking(String path)
|
List<String> |
readDirBlocking(String path,
String filter)
|
FileSystem |
readFile(String path)
Reads the entire file as represented by the path
path as a , asynchronously. |
FileSystem |
readFile(String path,
Handler<AsyncResult<Buffer>> handler)
Reads the entire file as represented by the path
path as a , asynchronously. |
Buffer |
readFileBlocking(String path)
|
FileSystem |
readSymlink(String link)
Returns the path representing the file that the symbolic link specified by
link points to, asynchronously. |
FileSystem |
readSymlink(String link,
Handler<AsyncResult<String>> handler)
Returns the path representing the file that the symbolic link specified by
link points to, asynchronously. |
String |
readSymlinkBlocking(String link)
|
Completable |
rxChmod(String path,
String perms)
Change the permissions on the file represented by
path to perms , asynchronously. |
Completable |
rxChmodRecursive(String path,
String perms,
String dirPerms)
Change the permissions on the file represented by
path to perms , asynchronously. |
Completable |
rxChown(String path,
String user,
String group)
Change the ownership on the file represented by
path to user and {code group}, asynchronously. |
Completable |
rxCopy(String from,
String to)
Copy a file from the path
from to path to , asynchronously. |
Completable |
rxCopy(String from,
String to,
CopyOptions options)
Copy a file from the path
from to path to , asynchronously. |
Completable |
rxCopyRecursive(String from,
String to,
boolean recursive)
Copy a file from the path
from to path to , asynchronously. |
Completable |
rxCreateFile(String path)
Creates an empty file with the specified
path , asynchronously. |
Completable |
rxCreateFile(String path,
String perms)
Creates an empty file with the specified
path and permissions perms , asynchronously. |
Single<String> |
rxCreateTempDirectory(String prefix)
Creates a new directory in the default temporary-file directory, using the given
prefix to generate its name, asynchronously.
|
Single<String> |
rxCreateTempDirectory(String prefix,
String perms)
Creates a new directory in the default temporary-file directory, using the given
prefix to generate its name, asynchronously.
|
Single<String> |
rxCreateTempDirectory(String dir,
String prefix,
String perms)
Creates a new directory in the directory provided by the path
path , using the given
prefix to generate its name, asynchronously. |
Single<String> |
rxCreateTempFile(String prefix,
String suffix)
Creates a new file in the default temporary-file directory, using the given
prefix and suffix to generate its name, asynchronously.
|
Single<String> |
rxCreateTempFile(String prefix,
String suffix,
String perms)
Creates a new file in the directory provided by the path
dir , using the given
prefix and suffix to generate its name, asynchronously. |
Single<String> |
rxCreateTempFile(String dir,
String prefix,
String suffix,
String perms)
Creates a new file in the directory provided by the path
dir , using the given
prefix and suffix to generate its name, asynchronously. |
Completable |
rxDelete(String path)
Deletes the file represented by the specified
path , asynchronously. |
Completable |
rxDeleteRecursive(String path,
boolean recursive)
Deletes the file represented by the specified
path , asynchronously. |
Single<Boolean> |
rxExists(String path)
Determines whether the file as specified by the path
path exists, asynchronously. |
Single<FileSystemProps> |
rxFsProps(String path)
Returns properties of the file-system being used by the specified
path , asynchronously. |
Completable |
rxLink(String link,
String existing)
Create a hard link on the file system from
link to existing , asynchronously. |
Single<FileProps> |
rxLprops(String path)
Obtain properties for the link represented by
path , asynchronously. |
Completable |
rxMkdir(String path)
Create the directory represented by
path , asynchronously. |
Completable |
rxMkdir(String path,
String perms)
Create the directory represented by
path , asynchronously. |
Completable |
rxMkdirs(String path)
Create the directory represented by
path and any non existent parents, asynchronously. |
Completable |
rxMkdirs(String path,
String perms)
Create the directory represented by
path and any non existent parents, asynchronously. |
Completable |
rxMove(String from,
String to)
Move a file from the path
from to path to , asynchronously. |
Completable |
rxMove(String from,
String to,
CopyOptions options)
Move a file from the path
from to path to , asynchronously. |
Single<AsyncFile> |
rxOpen(String path,
OpenOptions options)
Open the file represented by
path , asynchronously. |
Single<FileProps> |
rxProps(String path)
Obtain properties for the file represented by
path , asynchronously. |
Single<List<String>> |
rxReadDir(String path)
Read the contents of the directory specified by
path , asynchronously. |
Single<List<String>> |
rxReadDir(String path,
String filter)
Read the contents of the directory specified by
path , asynchronously. |
Single<Buffer> |
rxReadFile(String path)
Reads the entire file as represented by the path
path as a , asynchronously. |
Single<String> |
rxReadSymlink(String link)
Returns the path representing the file that the symbolic link specified by
link points to, asynchronously. |
Completable |
rxSymlink(String link,
String existing)
Create a symbolic link on the file system from
link to existing , asynchronously. |
Completable |
rxTruncate(String path,
long len)
Truncate the file represented by
path to length len in bytes, asynchronously. |
Completable |
rxUnlink(String link)
Unlinks the link on the file system represented by the path
link , asynchronously. |
Completable |
rxWriteFile(String path,
Buffer data)
Creates the file, and writes the specified
Buffer data to the file represented by the path path ,
asynchronously. |
FileSystem |
symlink(String link,
String existing)
Create a symbolic link on the file system from
link to existing , asynchronously. |
FileSystem |
symlink(String link,
String existing,
Handler<AsyncResult<Void>> handler)
Create a symbolic link on the file system from
link to existing , asynchronously. |
FileSystem |
symlinkBlocking(String link,
String existing)
|
String |
toString() |
FileSystem |
truncate(String path,
long len)
Truncate the file represented by
path to length len in bytes, asynchronously. |
FileSystem |
truncate(String path,
long len,
Handler<AsyncResult<Void>> handler)
Truncate the file represented by
path to length len in bytes, asynchronously. |
FileSystem |
truncateBlocking(String path,
long len)
|
FileSystem |
unlink(String link)
Unlinks the link on the file system represented by the path
link , asynchronously. |
FileSystem |
unlink(String link,
Handler<AsyncResult<Void>> handler)
Unlinks the link on the file system represented by the path
link , asynchronously. |
FileSystem |
unlinkBlocking(String link)
|
FileSystem |
writeFile(String path,
Buffer data)
Creates the file, and writes the specified
Buffer data to the file represented by the path path ,
asynchronously. |
FileSystem |
writeFile(String path,
Buffer data,
Handler<AsyncResult<Void>> handler)
Creates the file, and writes the specified
Buffer data to the file represented by the path path ,
asynchronously. |
FileSystem |
writeFileBlocking(String path,
Buffer data)
|
public static final io.vertx.lang.rx.TypeArg<FileSystem> __TYPE_ARG
public FileSystem(FileSystem delegate)
public FileSystem(Object delegate)
public FileSystem getDelegate()
public FileSystem copy(String from, String to, Handler<AsyncResult<Void>> handler)
from
to path to
, asynchronously.
The copy will fail if the destination already exists.
from
- the path to copy fromto
- the path to copy tohandler
- the handler that will be called on completionpublic FileSystem copy(String from, String to)
from
to path to
, asynchronously.
The copy will fail if the destination already exists.
from
- the path to copy fromto
- the path to copy topublic Completable rxCopy(String from, String to)
from
to path to
, asynchronously.
The copy will fail if the destination already exists.
from
- the path to copy fromto
- the path to copy topublic FileSystem copy(String from, String to, CopyOptions options, Handler<AsyncResult<Void>> handler)
from
to path to
, asynchronously.from
- the path to copy fromto
- the path to copy tooptions
- options describing how the file should be copiedhandler
- the handler that will be called on completionpublic FileSystem copy(String from, String to, CopyOptions options)
from
to path to
, asynchronously.from
- the path to copy fromto
- the path to copy tooptions
- options describing how the file should be copiedpublic Completable rxCopy(String from, String to, CopyOptions options)
from
to path to
, asynchronously.from
- the path to copy fromto
- the path to copy tooptions
- options describing how the file should be copiedpublic FileSystem copyBlocking(String from, String to)
copy(java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)
from
- to
- public FileSystem copyRecursive(String from, String to, boolean recursive, Handler<AsyncResult<Void>> handler)
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.
from
- the path to copy fromto
- the path to copy torecursive
- handler
- the handler that will be called on completionpublic FileSystem copyRecursive(String from, String to, boolean recursive)
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.
from
- the path to copy fromto
- the path to copy torecursive
- public Completable rxCopyRecursive(String from, String to, boolean recursive)
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.
from
- the path to copy fromto
- the path to copy torecursive
- public FileSystem copyRecursiveBlocking(String from, String to, boolean recursive)
copyRecursive(java.lang.String, java.lang.String, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)
from
- to
- recursive
- public FileSystem move(String from, String to, Handler<AsyncResult<Void>> handler)
from
to path to
, asynchronously.
The move will fail if the destination already exists.
from
- the path to copy fromto
- the path to copy tohandler
- the handler that will be called on completionpublic FileSystem move(String from, String to)
from
to path to
, asynchronously.
The move will fail if the destination already exists.
from
- the path to copy fromto
- the path to copy topublic Completable rxMove(String from, String to)
from
to path to
, asynchronously.
The move will fail if the destination already exists.
from
- the path to copy fromto
- the path to copy topublic FileSystem move(String from, String to, CopyOptions options, Handler<AsyncResult<Void>> handler)
from
to path to
, asynchronously.from
- the path to copy fromto
- the path to copy tooptions
- options describing how the file should be copiedhandler
- the handler that will be called on completionpublic FileSystem move(String from, String to, CopyOptions options)
from
to path to
, asynchronously.from
- the path to copy fromto
- the path to copy tooptions
- options describing how the file should be copiedpublic Completable rxMove(String from, String to, CopyOptions options)
from
to path to
, asynchronously.from
- the path to copy fromto
- the path to copy tooptions
- options describing how the file should be copiedpublic FileSystem moveBlocking(String from, String to)
move(java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)
from
- to
- public FileSystem truncate(String path, long len, Handler<AsyncResult<Void>> handler)
path
to length len
in bytes, asynchronously.
The operation will fail if the file does not exist or len
is less than zero
.
path
- the path to the filelen
- the length to truncate it tohandler
- the handler that will be called on completionpublic FileSystem truncate(String path, long len)
path
to length len
in bytes, asynchronously.
The operation will fail if the file does not exist or len
is less than zero
.
path
- the path to the filelen
- the length to truncate it topublic Completable rxTruncate(String path, long len)
path
to length len
in bytes, asynchronously.
The operation will fail if the file does not exist or len
is less than zero
.
path
- the path to the filelen
- the length to truncate it topublic FileSystem truncateBlocking(String path, long len)
truncate(java.lang.String, long, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)
path
- len
- public FileSystem chmod(String path, String perms, Handler<AsyncResult<Void>> handler)
path
to perms
, asynchronously.
The permission String takes the form rwxr-x--- as specified here.
path
- the path to the fileperms
- the permissions stringhandler
- the handler that will be called on completionpublic FileSystem chmod(String path, String perms)
path
to perms
, asynchronously.
The permission String takes the form rwxr-x--- as specified here.
path
- the path to the fileperms
- the permissions stringpublic Completable rxChmod(String path, String perms)
path
to perms
, asynchronously.
The permission String takes the form rwxr-x--- as specified here.
path
- the path to the fileperms
- the permissions stringpublic FileSystem chmodBlocking(String path, String perms)
#chmod(String, String, Handler)
path
- perms
- public FileSystem chmodRecursive(String path, String perms, String dirPerms, Handler<AsyncResult<Void>> handler)
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
.
path
- the path to the fileperms
- the permissions stringdirPerms
- the directory permissionshandler
- the handler that will be called on completionpublic FileSystem chmodRecursive(String path, String perms, String dirPerms)
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
.
path
- the path to the fileperms
- the permissions stringdirPerms
- the directory permissionspublic Completable rxChmodRecursive(String path, String perms, String dirPerms)
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
.
path
- the path to the fileperms
- the permissions stringdirPerms
- the directory permissionspublic FileSystem chmodRecursiveBlocking(String path, String perms, String dirPerms)
chmodRecursive(java.lang.String, java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)
path
- perms
- dirPerms
- public FileSystem chown(String path, String user, String group, Handler<AsyncResult<Void>> handler)
path
to user
and {code group}, asynchronously.path
- the path to the fileuser
- the user name, null
will not change the user namegroup
- the user group, null
will not change the user group namehandler
- the handler that will be called on completionpublic FileSystem chown(String path, String user, String group)
path
to user
and {code group}, asynchronously.path
- the path to the fileuser
- the user name, null
will not change the user namegroup
- the user group, null
will not change the user group namepublic Completable rxChown(String path, String user, String group)
path
to user
and {code group}, asynchronously.path
- the path to the fileuser
- the user name, null
will not change the user namegroup
- the user group, null
will not change the user group namepublic FileSystem chownBlocking(String path, String user, String group)
chown(java.lang.String, java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)
path
- user
- group
- public FileSystem props(String path, Handler<AsyncResult<FileProps>> handler)
path
, asynchronously.
If the file is a link, the link will be followed.
path
- the path to the filehandler
- the handler that will be called on completionpublic FileSystem props(String path)
path
, asynchronously.
If the file is a link, the link will be followed.
path
- the path to the filepublic Single<FileProps> rxProps(String path)
path
, asynchronously.
If the file is a link, the link will be followed.
path
- the path to the filepublic FileProps propsBlocking(String path)
props(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.file.FileProps>>)
path
- public FileSystem lprops(String path, Handler<AsyncResult<FileProps>> handler)
path
, asynchronously.
The link will not be followed.
path
- the path to the filehandler
- the handler that will be called on completionpublic FileSystem lprops(String path)
path
, asynchronously.
The link will not be followed.
path
- the path to the filepublic Single<FileProps> rxLprops(String path)
path
, asynchronously.
The link will not be followed.
path
- the path to the filepublic FileProps lpropsBlocking(String path)
lprops(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.file.FileProps>>)
path
- public FileSystem link(String link, String existing, Handler<AsyncResult<Void>> handler)
link
to existing
, asynchronously.link
- the linkexisting
- the link destinationhandler
- the handler that will be called on completionpublic FileSystem link(String link, String existing)
link
to existing
, asynchronously.link
- the linkexisting
- the link destinationpublic Completable rxLink(String link, String existing)
link
to existing
, asynchronously.link
- the linkexisting
- the link destinationpublic FileSystem linkBlocking(String link, String existing)
link(java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)
link
- existing
- public FileSystem symlink(String link, String existing, Handler<AsyncResult<Void>> handler)
link
to existing
, asynchronously.link
- the linkexisting
- the link destinationhandler
- the handler that will be called on completionpublic FileSystem symlink(String link, String existing)
link
to existing
, asynchronously.link
- the linkexisting
- the link destinationpublic Completable rxSymlink(String link, String existing)
link
to existing
, asynchronously.link
- the linkexisting
- the link destinationpublic FileSystem symlinkBlocking(String link, String existing)
link(java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)
link
- existing
- public FileSystem unlink(String link, Handler<AsyncResult<Void>> handler)
link
, asynchronously.link
- the linkhandler
- the handler that will be called on completionpublic FileSystem unlink(String link)
link
, asynchronously.link
- the linkpublic Completable rxUnlink(String link)
link
, asynchronously.link
- the linkpublic FileSystem unlinkBlocking(String link)
unlink(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)
link
- public FileSystem readSymlink(String link, Handler<AsyncResult<String>> handler)
link
points to, asynchronously.link
- the linkhandler
- the handler that will be called on completionpublic FileSystem readSymlink(String link)
link
points to, asynchronously.link
- the linkpublic Single<String> rxReadSymlink(String link)
link
points to, asynchronously.link
- the linkpublic String readSymlinkBlocking(String link)
readSymlink(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)
link
- public FileSystem delete(String path, Handler<AsyncResult<Void>> handler)
path
, asynchronously.path
- path to the filehandler
- the handler that will be called on completionpublic FileSystem delete(String path)
path
, asynchronously.path
- path to the filepublic Completable rxDelete(String path)
path
, asynchronously.path
- path to the filepublic FileSystem deleteBlocking(String path)
delete(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)
path
- public FileSystem deleteRecursive(String path, boolean recursive, Handler<AsyncResult<Void>> handler)
path
, asynchronously.
If the path represents a directory and recursive = true
then the directory and its contents will be
deleted recursively.
path
- path to the filerecursive
- delete recursively?handler
- the handler that will be called on completionpublic FileSystem deleteRecursive(String path, boolean recursive)
path
, asynchronously.
If the path represents a directory and recursive = true
then the directory and its contents will be
deleted recursively.
path
- path to the filerecursive
- delete recursively?public Completable rxDeleteRecursive(String path, boolean recursive)
path
, asynchronously.
If the path represents a directory and recursive = true
then the directory and its contents will be
deleted recursively.
path
- path to the filerecursive
- delete recursively?public FileSystem deleteRecursiveBlocking(String path, boolean recursive)
deleteRecursive(java.lang.String, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)
path
- recursive
- public FileSystem mkdir(String path, Handler<AsyncResult<Void>> handler)
path
, asynchronously.
The operation will fail if the directory already exists.
path
- path to the filehandler
- the handler that will be called on completionpublic FileSystem mkdir(String path)
path
, asynchronously.
The operation will fail if the directory already exists.
path
- path to the filepublic Completable rxMkdir(String path)
path
, asynchronously.
The operation will fail if the directory already exists.
path
- path to the filepublic FileSystem mkdirBlocking(String path)
mkdir(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)
path
- public FileSystem mkdir(String path, String perms, Handler<AsyncResult<Void>> handler)
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.
path
- path to the fileperms
- the permissions stringhandler
- the handler that will be called on completionpublic FileSystem mkdir(String path, String perms)
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.
path
- path to the fileperms
- the permissions stringpublic Completable rxMkdir(String path, String perms)
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.
path
- path to the fileperms
- the permissions stringpublic FileSystem mkdirBlocking(String path, String perms)
mkdir(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)
path
- perms
- public FileSystem mkdirs(String path, Handler<AsyncResult<Void>> handler)
path
and any non existent parents, asynchronously.
The operation will fail if the path
already exists but is not a directory.
path
- path to the filehandler
- the handler that will be called on completionpublic FileSystem mkdirs(String path)
path
and any non existent parents, asynchronously.
The operation will fail if the path
already exists but is not a directory.
path
- path to the filepublic Completable rxMkdirs(String path)
path
and any non existent parents, asynchronously.
The operation will fail if the path
already exists but is not a directory.
path
- path to the filepublic FileSystem mkdirsBlocking(String path)
mkdirs(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)
path
- public FileSystem mkdirs(String path, String perms, Handler<AsyncResult<Void>> handler)
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.
path
- path to the fileperms
- the permissions stringhandler
- the handler that will be called on completionpublic FileSystem mkdirs(String path, String perms)
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.
path
- path to the fileperms
- the permissions stringpublic Completable rxMkdirs(String path, String perms)
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.
path
- path to the fileperms
- the permissions stringpublic FileSystem mkdirsBlocking(String path, String perms)
mkdirs(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)
path
- perms
- public FileSystem readDir(String path, Handler<AsyncResult<List<String>>> handler)
path
, asynchronously.
The result is an array of String representing the paths of the files inside the directory.
path
- path to the filehandler
- the handler that will be called on completionpublic FileSystem readDir(String path)
path
, asynchronously.
The result is an array of String representing the paths of the files inside the directory.
path
- path to the filepublic Single<List<String>> rxReadDir(String path)
path
, asynchronously.
The result is an array of String representing the paths of the files inside the directory.
path
- path to the filepublic List<String> readDirBlocking(String path)
readDir(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.util.List<java.lang.String>>>)
path
- public FileSystem readDir(String path, String filter, Handler<AsyncResult<List<String>>> handler)
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.
path
- path to the directoryfilter
- the filter expressionhandler
- the handler that will be called on completionpublic FileSystem readDir(String path, String filter)
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.
path
- path to the directoryfilter
- the filter expressionpublic Single<List<String>> rxReadDir(String path, String filter)
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.
path
- path to the directoryfilter
- the filter expressionpublic List<String> readDirBlocking(String path, String filter)
readDir(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.util.List<java.lang.String>>>)
path
- filter
- public FileSystem readFile(String path, Handler<AsyncResult<Buffer>> handler)
path
as a , asynchronously.
Do not use this method to read very large files or you risk running out of available RAM.
path
- path to the filehandler
- the handler that will be called on completionpublic FileSystem readFile(String path)
path
as a , asynchronously.
Do not use this method to read very large files or you risk running out of available RAM.
path
- path to the filepublic Single<Buffer> rxReadFile(String path)
path
as a , asynchronously.
Do not use this method to read very large files or you risk running out of available RAM.
path
- path to the filepublic Buffer readFileBlocking(String path)
readFile(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.buffer.Buffer>>)
path
- public FileSystem writeFile(String path, Buffer data, Handler<AsyncResult<Void>> handler)
Buffer data
to the file represented by the path path
,
asynchronously.path
- path to the filedata
- handler
- the handler that will be called on completionpublic FileSystem writeFile(String path, Buffer data)
Buffer data
to the file represented by the path path
,
asynchronously.path
- path to the filedata
- public Completable rxWriteFile(String path, Buffer data)
Buffer data
to the file represented by the path path
,
asynchronously.path
- path to the filedata
- public FileSystem writeFileBlocking(String path, Buffer data)
writeFile(java.lang.String, io.vertx.reactivex.core.buffer.Buffer, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)
path
- data
- public FileSystem open(String path, OpenOptions options, Handler<AsyncResult<AsyncFile>> handler)
path
, asynchronously.
The file is opened for both reading and writing. If the file does not already exist it will be created.
path
- path to the fileoptions
- options describing how the file should be openedhandler
- public FileSystem open(String path, OpenOptions options)
path
, asynchronously.
The file is opened for both reading and writing. If the file does not already exist it will be created.
path
- path to the fileoptions
- options describing how the file should be openedpublic Single<AsyncFile> rxOpen(String path, OpenOptions options)
path
, asynchronously.
The file is opened for both reading and writing. If the file does not already exist it will be created.
path
- path to the fileoptions
- options describing how the file should be openedpublic AsyncFile openBlocking(String path, OpenOptions options)
open(java.lang.String, io.vertx.core.file.OpenOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.file.AsyncFile>>)
path
- options
- public FileSystem createFile(String path, Handler<AsyncResult<Void>> handler)
path
, asynchronously.path
- path to the filehandler
- the handler that will be called on completionpublic FileSystem createFile(String path)
path
, asynchronously.path
- path to the filepublic Completable rxCreateFile(String path)
path
, asynchronously.path
- path to the filepublic FileSystem createFileBlocking(String path)
createFile(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)
path
- public FileSystem createFile(String path, String perms, Handler<AsyncResult<Void>> handler)
path
and permissions perms
, asynchronously.path
- path to the fileperms
- the permissions stringhandler
- the handler that will be called on completionpublic FileSystem createFile(String path, String perms)
path
and permissions perms
, asynchronously.path
- path to the fileperms
- the permissions stringpublic Completable rxCreateFile(String path, String perms)
path
and permissions perms
, asynchronously.path
- path to the fileperms
- the permissions stringpublic FileSystem createFileBlocking(String path, String perms)
createFile(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)
path
- perms
- public FileSystem exists(String path, Handler<AsyncResult<Boolean>> handler)
path
exists, asynchronously.path
- path to the filehandler
- the handler that will be called on completionpublic FileSystem exists(String path)
path
exists, asynchronously.path
- path to the filepublic Single<Boolean> rxExists(String path)
path
exists, asynchronously.path
- path to the filepublic boolean existsBlocking(String path)
exists(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Boolean>>)
path
- public FileSystem fsProps(String path, Handler<AsyncResult<FileSystemProps>> handler)
path
, asynchronously.path
- path to anywhere on the filesystemhandler
- the handler that will be called on completionpublic FileSystem fsProps(String path)
path
, asynchronously.path
- path to anywhere on the filesystempublic Single<FileSystemProps> rxFsProps(String path)
path
, asynchronously.path
- path to anywhere on the filesystempublic FileSystemProps fsPropsBlocking(String path)
fsProps(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.file.FileSystemProps>>)
path
- public FileSystem createTempDirectory(String prefix, Handler<AsyncResult<String>> handler)
As with the File.createTempFile
methods, this method is only
part of a temporary-file facility.A Runtime
,
or the File
mechanism may be used to delete the directory automatically.
prefix
- the prefix string to be used in generating the directory's name; may be null
handler
- the handler that will be called on completionpublic FileSystem createTempDirectory(String prefix)
As with the File.createTempFile
methods, this method is only
part of a temporary-file facility.A Runtime
,
or the File
mechanism may be used to delete the directory automatically.
prefix
- the prefix string to be used in generating the directory's name; may be null
public Single<String> rxCreateTempDirectory(String prefix)
As with the File.createTempFile
methods, this method is only
part of a temporary-file facility.A Runtime
,
or the File
mechanism may be used to delete the directory automatically.
prefix
- the prefix string to be used in generating the directory's name; may be null
public String createTempDirectoryBlocking(String prefix)
createTempDirectory(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)
prefix
- public FileSystem createTempDirectory(String prefix, String perms, Handler<AsyncResult<String>> handler)
The new directory will be created with permissions as specified by perms
.
As with the File.createTempFile
methods, this method is only
part of a temporary-file facility.A Runtime
,
or the File
mechanism may be used to delete the directory automatically.
prefix
- the prefix string to be used in generating the directory's name; may be null
perms
- the permissions stringhandler
- the handler that will be called on completionpublic FileSystem createTempDirectory(String prefix, String perms)
The new directory will be created with permissions as specified by perms
.
As with the File.createTempFile
methods, this method is only
part of a temporary-file facility.A Runtime
,
or the File
mechanism may be used to delete the directory automatically.
prefix
- the prefix string to be used in generating the directory's name; may be null
perms
- the permissions stringpublic Single<String> rxCreateTempDirectory(String prefix, String perms)
The new directory will be created with permissions as specified by perms
.
As with the File.createTempFile
methods, this method is only
part of a temporary-file facility.A Runtime
,
or the File
mechanism may be used to delete the directory automatically.
prefix
- the prefix string to be used in generating the directory's name; may be null
perms
- the permissions stringpublic String createTempDirectoryBlocking(String prefix, String perms)
createTempDirectory(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)
prefix
- perms
- public FileSystem createTempDirectory(String dir, String prefix, String perms, Handler<AsyncResult<String>> handler)
path
, using the given
prefix to generate its name, asynchronously.
The new directory will be created with permissions as specified by perms
.
As with the File.createTempFile
methods, this method is only
part of a temporary-file facility.A Runtime
,
or the File
mechanism may be used to delete the directory automatically.
dir
- the path to directory in which to create the directoryprefix
- the prefix string to be used in generating the directory's name; may be null
perms
- the permissions stringhandler
- the handler that will be called on completionpublic FileSystem createTempDirectory(String dir, String prefix, String perms)
path
, using the given
prefix to generate its name, asynchronously.
The new directory will be created with permissions as specified by perms
.
As with the File.createTempFile
methods, this method is only
part of a temporary-file facility.A Runtime
,
or the File
mechanism may be used to delete the directory automatically.
dir
- the path to directory in which to create the directoryprefix
- the prefix string to be used in generating the directory's name; may be null
perms
- the permissions stringpublic Single<String> rxCreateTempDirectory(String dir, String prefix, String perms)
path
, using the given
prefix to generate its name, asynchronously.
The new directory will be created with permissions as specified by perms
.
As with the File.createTempFile
methods, this method is only
part of a temporary-file facility.A Runtime
,
or the File
mechanism may be used to delete the directory automatically.
dir
- the path to directory in which to create the directoryprefix
- the prefix string to be used in generating the directory's name; may be null
perms
- the permissions stringpublic String createTempDirectoryBlocking(String dir, String prefix, String perms)
createTempDirectory(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)
dir
- prefix
- perms
- public FileSystem createTempFile(String prefix, String suffix, Handler<AsyncResult<String>> handler)
As with the File.createTempFile
methods, this method is only
part of a temporary-file facility.A Runtime
,
or the File
mechanism may be used to delete the directory automatically.
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 usedhandler
- the handler that will be called on completionpublic FileSystem createTempFile(String prefix, String suffix)
As with the File.createTempFile
methods, this method is only
part of a temporary-file facility.A Runtime
,
or the File
mechanism may be used to delete the directory automatically.
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 usedpublic Single<String> rxCreateTempFile(String prefix, String suffix)
As with the File.createTempFile
methods, this method is only
part of a temporary-file facility.A Runtime
,
or the File
mechanism may be used to delete the directory automatically.
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 usedpublic String createTempFileBlocking(String prefix, String suffix)
createTempFile(java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)
prefix
- suffix
- public FileSystem createTempFile(String prefix, String suffix, String perms, Handler<AsyncResult<String>> handler)
dir
, using the given
prefix and suffix to generate its name, asynchronously.
As with the File.createTempFile
methods, this method is only
part of a temporary-file facility.A Runtime
,
or the File
mechanism may be used to delete the directory automatically.
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 usedperms
- handler
- the handler that will be called on completionpublic FileSystem createTempFile(String prefix, String suffix, String perms)
dir
, using the given
prefix and suffix to generate its name, asynchronously.
As with the File.createTempFile
methods, this method is only
part of a temporary-file facility.A Runtime
,
or the File
mechanism may be used to delete the directory automatically.
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 usedperms
- public Single<String> rxCreateTempFile(String prefix, String suffix, String perms)
dir
, using the given
prefix and suffix to generate its name, asynchronously.
As with the File.createTempFile
methods, this method is only
part of a temporary-file facility.A Runtime
,
or the File
mechanism may be used to delete the directory automatically.
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 usedperms
- public String createTempFileBlocking(String prefix, String suffix, String perms)
createTempFile(java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)
prefix
- suffix
- perms
- public FileSystem createTempFile(String dir, String prefix, String suffix, String perms, Handler<AsyncResult<String>> handler)
dir
, using the given
prefix and suffix to generate its name, asynchronously.
The new directory will be created with permissions as specified by perms
.
As with the File.createTempFile
methods, this method is only
part of a temporary-file facility.A Runtime
,
or the File
mechanism may be used to delete the directory automatically.
dir
- the path to directory in which to create the directoryprefix
- 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 usedperms
- the permissions stringhandler
- the handler that will be called on completionpublic FileSystem createTempFile(String dir, String prefix, String suffix, String perms)
dir
, using the given
prefix and suffix to generate its name, asynchronously.
The new directory will be created with permissions as specified by perms
.
As with the File.createTempFile
methods, this method is only
part of a temporary-file facility.A Runtime
,
or the File
mechanism may be used to delete the directory automatically.
dir
- the path to directory in which to create the directoryprefix
- 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 usedperms
- the permissions stringpublic Single<String> rxCreateTempFile(String dir, String prefix, String suffix, String perms)
dir
, using the given
prefix and suffix to generate its name, asynchronously.
The new directory will be created with permissions as specified by perms
.
As with the File.createTempFile
methods, this method is only
part of a temporary-file facility.A Runtime
,
or the File
mechanism may be used to delete the directory automatically.
dir
- the path to directory in which to create the directoryprefix
- 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 usedperms
- the permissions stringpublic String createTempFileBlocking(String dir, String prefix, String suffix, String perms)
createTempFile(java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)
dir
- prefix
- suffix
- perms
- public static FileSystem newInstance(FileSystem arg)
Copyright © 2023 Eclipse. All rights reserved.