FileSystemImpl (Vert.x Core 3.0.0 API)

java.lang.Object
- io.vertx.core.file.impl.FileSystemImpl

All Implemented Interfaces:

FileSystem

Direct Known Subclasses:

WindowsFileSystem
```
public class FileSystemImpl
extends Object
implements FileSystem
```
This class is thread-safe

Author:

Tim Fox

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

protected class FileSystemImpl.BlockingAction<T>

Nested Classes
Modifier and Type	Class and Description
`protected class`	`FileSystemImpl.BlockingAction<T>`

Field Summary

Fields
Modifier and Type Field and Description

protected VertxInternal vertx

Fields
Modifier and Type	Field and Description
`protected VertxInternal`	`vertx`

Constructor Summary

Constructors
Constructor and Description

FileSystemImpl(VertxInternal vertx)

Constructors
Constructor and Description
`FileSystemImpl(VertxInternal vertx)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`FileSystem`	`chmod(String path, String perms, Handler<AsyncResult<Void>> handler)` Change the permissions on the file represented by `path` to `perms`, asynchronously.
`FileSystem`	`chmodBlocking(String path, String perms)` Blocking version of `FileSystem.chmod(String, String, Handler)`
`protected FileSystemImpl.BlockingAction<Void>`	`chmodInternal(String path, String perms, String dirPerms, Handler<AsyncResult<Void>> handler)`
`FileSystem`	`chmodRecursive(String path, String perms, String dirPerms, Handler<AsyncResult<Void>> handler)` Change the permissions on the file represented by `path` to `perms`, asynchronously.
`FileSystem`	`chmodRecursiveBlocking(String path, String perms, String dirPerms)` Blocking version of `FileSystem.chmodRecursive(String, String, String, Handler)`
`FileSystem`	`chown(String path, String user, String group, Handler<AsyncResult<Void>> handler)` Change the ownership on the file represented by `path` to `user` and {code group}, asynchronously.
`FileSystem`	`chownBlocking(String path, String user, String group)` Blocking version of `FileSystem.chown(String, String, String, Handler)`
`protected FileSystemImpl.BlockingAction<Void>`	`chownInternal(String path, String user, String group, Handler<AsyncResult<Void>> handler)`
`FileSystem`	`copy(String from, String to, Handler<AsyncResult<Void>> handler)` Copy a file from the path `from` to path `to`, asynchronously.
`FileSystem`	`copyBlocking(String from, String to)` Blocking version of `FileSystem.copy(String, String, Handler)`
`FileSystem`	`copyRecursive(String from, String to, boolean recursive, Handler<AsyncResult<Void>> handler)` Copy a file from the path `from` to path `to`, asynchronously.
`FileSystem`	`copyRecursiveBlocking(String from, String to, boolean recursive)` Blocking version of `FileSystem.copyRecursive(String, String, boolean, Handler)`
`FileSystem`	`createFile(String path, Handler<AsyncResult<Void>> handler)` Creates an empty file with the specified `path`, asynchronously.
`FileSystem`	`createFile(String path, String perms, Handler<AsyncResult<Void>> handler)` Creates an empty file with the specified `path` and permissions `perms`, asynchronously.
`FileSystem`	`createFileBlocking(String path)` Blocking version of `FileSystem.createFile(String, Handler)`
`FileSystem`	`createFileBlocking(String path, String perms)` Blocking version of `FileSystem.createFile(String, String, Handler)`
`protected FileSystemImpl.BlockingAction<Void>`	`createFileInternal(String p, String perms, Handler<AsyncResult<Void>> handler)`
`FileSystem`	`delete(String path, Handler<AsyncResult<Void>> handler)` Deletes the file represented by the specified `path`, asynchronously.
`FileSystem`	`deleteBlocking(String path)` Blocking version of `FileSystem.delete(String, Handler)`
`FileSystem`	`deleteRecursive(String path, boolean recursive, Handler<AsyncResult<Void>> handler)` Deletes the file represented by the specified `path`, asynchronously.
`FileSystem`	`deleteRecursiveBlocking(String path, boolean recursive)` Blocking version of `FileSystem.deleteRecursive(String, boolean, Handler)`
`protected AsyncFile`	`doOpen(String path, OpenOptions options, ContextImpl context)`
`FileSystem`	`exists(String path, Handler<AsyncResult<Boolean>> handler)` Determines whether the file as specified by the path `path` exists, asynchronously.
`boolean`	`existsBlocking(String path)` Blocking version of `FileSystem.exists(String, Handler)`
`FileSystem`	`fsProps(String path, Handler<AsyncResult<FileSystemProps>> handler)` Returns properties of the file-system being used by the specified `path`, asynchronously.
`FileSystemProps`	`fsPropsBlocking(String path)` Blocking version of `FileSystem.fsProps(String, Handler)`
`FileSystem`	`link(String link, String existing, Handler<AsyncResult<Void>> handler)` Create a hard link on the file system from `link` to `existing`, asynchronously.
`FileSystem`	`linkBlocking(String link, String existing)` Blocking version of `FileSystem.link(String, String, Handler)`
`FileSystem`	`lprops(String path, Handler<AsyncResult<FileProps>> handler)` Obtain properties for the link represented by `path`, asynchronously.
`FileProps`	`lpropsBlocking(String path)` Blocking version of `FileSystem.lprops(String, Handler)`
`FileSystem`	`mkdir(String path, Handler<AsyncResult<Void>> handler)` Create the directory represented by `path`, asynchronously.
`FileSystem`	`mkdir(String path, String perms, Handler<AsyncResult<Void>> handler)` Create the directory represented by `path`, asynchronously.
`FileSystem`	`mkdirBlocking(String path)` Blocking version of `FileSystem.mkdir(String, Handler)`
`FileSystem`	`mkdirBlocking(String path, String perms)` Blocking version of `FileSystem.mkdir(String, String, Handler)`
`protected FileSystemImpl.BlockingAction<Void>`	`mkdirInternal(String path, String perms, boolean createParents, Handler<AsyncResult<Void>> handler)`
`FileSystem`	`mkdirs(String path, Handler<AsyncResult<Void>> handler)` Create the directory represented by `path` and any non existent parents, asynchronously.
`FileSystem`	`mkdirs(String path, String perms, Handler<AsyncResult<Void>> handler)` Create the directory represented by `path` and any non existent parents, asynchronously.
`FileSystem`	`mkdirsBlocking(String path)` Blocking version of `FileSystem.mkdirs(String, Handler)`
`FileSystem`	`mkdirsBlocking(String path, String perms)` Blocking version of `FileSystem.mkdirs(String, String, Handler)`
`FileSystem`	`move(String from, String to, Handler<AsyncResult<Void>> handler)` Move a file from the path `from` to path `to`, asynchronously.
`FileSystem`	`moveBlocking(String from, String to)` Blocking version of `FileSystem.move(String, String, Handler)`
`FileSystem`	`open(String path, OpenOptions options, Handler<AsyncResult<AsyncFile>> handler)` Open the file represented by `path`, asynchronously.
`AsyncFile`	`openBlocking(String path, OpenOptions options)` Blocking version of `FileSystem.open(String, io.vertx.core.file.OpenOptions, Handler)`
`FileSystem`	`props(String path, Handler<AsyncResult<FileProps>> handler)` Obtain properties for the file represented by `path`, asynchronously.
`FileProps`	`propsBlocking(String path)` Blocking version of `FileSystem.props(String, Handler)`
`FileSystem`	`readDir(String path, Handler<AsyncResult<List<String>>> handler)` Read the contents of the directory specified by `path`, asynchronously.
`FileSystem`	`readDir(String path, String filter, Handler<AsyncResult<List<String>>> handler)` Read the contents of the directory specified by `path`, asynchronously.
`List<String>`	`readDirBlocking(String path)` Blocking version of `FileSystem.readDir(String, Handler)`
`List<String>`	`readDirBlocking(String path, String filter)` Blocking version of `FileSystem.readDir(String, String, Handler)`
`FileSystem`	`readFile(String path, Handler<AsyncResult<Buffer>> handler)` Reads the entire file as represented by the path `path` as a `Buffer`, asynchronously.
`Buffer`	`readFileBlocking(String path)` Blocking version of `FileSystem.readFile(String, Handler)`
`FileSystem`	`readSymlink(String link, Handler<AsyncResult<String>> handler)` Returns the path representing the file that the symbolic link specified by `link` points to, asynchronously.
`String`	`readSymlinkBlocking(String link)` Blocking version of `FileSystem.readSymlink(String, Handler)`
`FileSystem`	`symlink(String link, String existing, Handler<AsyncResult<Void>> handler)` Create a symbolic link on the file system from `link` to `existing`, asynchronously.
`FileSystem`	`symlinkBlocking(String link, String existing)` Blocking version of `FileSystem.link(String, String, Handler)`
`FileSystem`	`truncate(String path, long len, Handler<AsyncResult<Void>> handler)` Truncate the file represented by `path` to length `len` in bytes, asynchronously.
`FileSystem`	`truncateBlocking(String path, long len)` Blocking version of `FileSystem.truncate(String, long, Handler)`
`FileSystem`	`unlink(String link, Handler<AsyncResult<Void>> handler)` Unlinks the link on the file system represented by the path `link`, asynchronously.
`FileSystem`	`unlinkBlocking(String link)` Blocking version of `FileSystem.unlink(String, Handler)`
`FileSystem`	`writeFile(String path, Buffer data, Handler<AsyncResult<Void>> handler)` Creates the file, and writes the specified `Buffer data` to the file represented by the path `path`, asynchronously.
`FileSystem`	`writeFileBlocking(String path, Buffer data)` Blocking version of `FileSystem.writeFile(String, Buffer, Handler)`

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

- Field Detail
  - vertx
```
protected final VertxInternal vertx
```
- Constructor Detail
  - FileSystemImpl
```
public FileSystemImpl(VertxInternal vertx)
```
- Method Detail
  - copy
```
public FileSystem copy(String from,
                       String to,
                       Handler<AsyncResult<Void>> handler)
```
    Description copied from interface: FileSystem
    
    Copy a file from the path from to path to, asynchronously.
    The copy will fail if the destination already exists.
    
    Specified by:
    
    copy in interface FileSystem
    
    Parameters:
    
    from - the path to copy from
    
    to - the path to copy to
    
    handler - the handler that will be called on completion
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - copyBlocking
```
public FileSystem copyBlocking(String from,
                               String to)
```
    Description copied from interface: FileSystem
    
    Blocking version of FileSystem.copy(String, String, Handler)
    
    Specified by:
    
    copyBlocking in interface FileSystem
  - copyRecursive
```
public FileSystem copyRecursive(String from,
                                String to,
                                boolean recursive,
                                Handler<AsyncResult<Void>> handler)
```
    Description copied from interface: FileSystem
    
    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.
    
    Specified by:
    
    copyRecursive in interface FileSystem
    
    Parameters:
    
    from - the path to copy from
    
    to - the path to copy to
    
    handler - the handler that will be called on completion
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - copyRecursiveBlocking
```
public FileSystem copyRecursiveBlocking(String from,
                                        String to,
                                        boolean recursive)
```
    Description copied from interface: FileSystem
    
    Blocking version of FileSystem.copyRecursive(String, String, boolean, Handler)
    
    Specified by:
    
    copyRecursiveBlocking in interface FileSystem
  - move
```
public FileSystem move(String from,
                       String to,
                       Handler<AsyncResult<Void>> handler)
```
    Description copied from interface: FileSystem
    
    Move a file from the path from to path to, asynchronously.
    The move will fail if the destination already exists.
    
    Specified by:
    
    move in interface FileSystem
    
    Parameters:
    
    from - the path to copy from
    
    to - the path to copy to
    
    handler - the handler that will be called on completion
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - moveBlocking
```
public FileSystem moveBlocking(String from,
                               String to)
```
    Description copied from interface: FileSystem
    
    Blocking version of FileSystem.move(String, String, Handler)
    
    Specified by:
    
    moveBlocking in interface FileSystem
  - truncate
```
public FileSystem truncate(String path,
                           long len,
                           Handler<AsyncResult<Void>> handler)
```
    Description copied from interface: FileSystem
    
    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.
    
    Specified by:
    
    truncate in interface FileSystem
    
    Parameters:
    
    path - the path to the file
    
    len - the length to truncate it to
    
    handler - the handler that will be called on completion
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - truncateBlocking
```
public FileSystem truncateBlocking(String path,
                                   long len)
```
    Description copied from interface: FileSystem
    
    Blocking version of FileSystem.truncate(String, long, Handler)
    
    Specified by:
    
    truncateBlocking in interface FileSystem
  - chmod
```
public FileSystem chmod(String path,
                        String perms,
                        Handler<AsyncResult<Void>> handler)
```
    Description copied from interface: FileSystem
    
    Change the permissions on the file represented by path to perms, asynchronously.
    The permission String takes the form rwxr-x--- as specified here.
    
    Specified by:
    
    chmod in interface FileSystem
    
    Parameters:
    
    path - the path to the file
    
    perms - the permissions string
    
    handler - the handler that will be called on completion
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - chmodBlocking
```
public FileSystem chmodBlocking(String path,
                                String perms)
```
    Description copied from interface: FileSystem
    
    Blocking version of FileSystem.chmod(String, String, Handler)
    
    Specified by:
    
    chmodBlocking in interface FileSystem
  - chmodRecursive
```
public FileSystem chmodRecursive(String path,
                                 String perms,
                                 String dirPerms,
                                 Handler<AsyncResult<Void>> handler)
```
    Description copied from interface: FileSystem
    
    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.
    
    Specified by:
    
    chmodRecursive in interface FileSystem
    
    Parameters:
    
    path - the path to the file
    
    perms - the permissions string
    
    dirPerms - the directory permissions
    
    handler - the handler that will be called on completion
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - chmodRecursiveBlocking
```
public FileSystem chmodRecursiveBlocking(String path,
                                         String perms,
                                         String dirPerms)
```
    Description copied from interface: FileSystem
    
    Blocking version of FileSystem.chmodRecursive(String, String, String, Handler)
    
    Specified by:
    
    chmodRecursiveBlocking in interface FileSystem
  - chown
```
public FileSystem chown(String path,
                        String user,
                        String group,
                        Handler<AsyncResult<Void>> handler)
```
    Description copied from interface: FileSystem
    
    Change the ownership on the file represented by path to user and {code group}, asynchronously.
    
    Specified by:
    
    chown in interface FileSystem
    
    Parameters:
    
    path - the path to the file
    
    user - the user name
    
    group - the user group
    
    handler - the handler that will be called on completion
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - chownBlocking
```
public FileSystem chownBlocking(String path,
                                String user,
                                String group)
```
    Description copied from interface: FileSystem
    
    Blocking version of FileSystem.chown(String, String, String, Handler)
    
    Specified by:
    
    chownBlocking in interface FileSystem
  - props
```
public FileSystem props(String path,
                        Handler<AsyncResult<FileProps>> handler)
```
    Description copied from interface: FileSystem
    
    Obtain properties for the file represented by path, asynchronously.
    If the file is a link, the link will be followed.
    
    Specified by:
    
    props in interface FileSystem
    
    Parameters:
    
    path - the path to the file
    
    handler - the handler that will be called on completion
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - propsBlocking
```
public FileProps propsBlocking(String path)
```
    Description copied from interface: FileSystem
    
    Blocking version of FileSystem.props(String, Handler)
    
    Specified by:
    
    propsBlocking in interface FileSystem
  - lprops
```
public FileSystem lprops(String path,
                         Handler<AsyncResult<FileProps>> handler)
```
    Description copied from interface: FileSystem
    
    Obtain properties for the link represented by path, asynchronously.
    The link will not be followed.
    
    Specified by:
    
    lprops in interface FileSystem
    
    Parameters:
    
    path - the path to the file
    
    handler - the handler that will be called on completion
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - lpropsBlocking
```
public FileProps lpropsBlocking(String path)
```
    Description copied from interface: FileSystem
    
    Blocking version of FileSystem.lprops(String, Handler)
    
    Specified by:
    
    lpropsBlocking in interface FileSystem
  - link
```
public FileSystem link(String link,
                       String existing,
                       Handler<AsyncResult<Void>> handler)
```
    Description copied from interface: FileSystem
    
    Create a hard link on the file system from link to existing, asynchronously.
    
    Specified by:
    
    link in interface FileSystem
    
    Parameters:
    
    link - the link
    
    existing - the link destination
    
    handler - the handler that will be called on completion
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - linkBlocking
```
public FileSystem linkBlocking(String link,
                               String existing)
```
    Description copied from interface: FileSystem
    
    Blocking version of FileSystem.link(String, String, Handler)
    
    Specified by:
    
    linkBlocking in interface FileSystem
  - symlink
```
public FileSystem symlink(String link,
                          String existing,
                          Handler<AsyncResult<Void>> handler)
```
    Description copied from interface: FileSystem
    
    Create a symbolic link on the file system from link to existing, asynchronously.
    
    Specified by:
    
    symlink in interface FileSystem
    
    Parameters:
    
    link - the link
    
    existing - the link destination
    
    handler - the handler that will be called on completion
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - symlinkBlocking
```
public FileSystem symlinkBlocking(String link,
                                  String existing)
```
    Description copied from interface: FileSystem
    
    Blocking version of FileSystem.link(String, String, Handler)
    
    Specified by:
    
    symlinkBlocking in interface FileSystem
  - unlink
```
public FileSystem unlink(String link,
                         Handler<AsyncResult<Void>> handler)
```
    Description copied from interface: FileSystem
    
    Unlinks the link on the file system represented by the path link, asynchronously.
    
    Specified by:
    
    unlink in interface FileSystem
    
    Parameters:
    
    link - the link
    
    handler - the handler that will be called on completion
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - unlinkBlocking
```
public FileSystem unlinkBlocking(String link)
```
    Description copied from interface: FileSystem
    
    Blocking version of FileSystem.unlink(String, Handler)
    
    Specified by:
    
    unlinkBlocking in interface FileSystem
  - readSymlink
```
public FileSystem readSymlink(String link,
                              Handler<AsyncResult<String>> handler)
```
    Description copied from interface: FileSystem
    
    Returns the path representing the file that the symbolic link specified by link points to, asynchronously.
    
    Specified by:
    
    readSymlink in interface FileSystem
    
    Parameters:
    
    link - the link
    
    handler - the handler that will be called on completion
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - readSymlinkBlocking
```
public String readSymlinkBlocking(String link)
```
    Description copied from interface: FileSystem
    
    Blocking version of FileSystem.readSymlink(String, Handler)
    
    Specified by:
    
    readSymlinkBlocking in interface FileSystem
  - delete
```
public FileSystem delete(String path,
                         Handler<AsyncResult<Void>> handler)
```
    Description copied from interface: FileSystem
    
    Deletes the file represented by the specified path, asynchronously.
    
    Specified by:
    
    delete in interface FileSystem
    
    Parameters:
    
    path - path to the file
    
    handler - the handler that will be called on completion
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - deleteBlocking
```
public FileSystem deleteBlocking(String path)
```
    Description copied from interface: FileSystem
    
    Blocking version of FileSystem.delete(String, Handler)
    
    Specified by:
    
    deleteBlocking in interface FileSystem
  - deleteRecursive
```
public FileSystem deleteRecursive(String path,
                                  boolean recursive,
                                  Handler<AsyncResult<Void>> handler)
```
    Description copied from interface: FileSystem
    
    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.
    
    Specified by:
    
    deleteRecursive in interface FileSystem
    
    Parameters:
    
    path - path to the file
    
    recursive - delete recursively?
    
    handler - the handler that will be called on completion
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - deleteRecursiveBlocking
```
public FileSystem deleteRecursiveBlocking(String path,
                                          boolean recursive)
```
    Description copied from interface: FileSystem
    
    Blocking version of FileSystem.deleteRecursive(String, boolean, Handler)
    
    Specified by:
    
    deleteRecursiveBlocking in interface FileSystem
  - mkdir
```
public FileSystem mkdir(String path,
                        Handler<AsyncResult<Void>> handler)
```
    Description copied from interface: FileSystem
    
    Create the directory represented by path, asynchronously.
    The operation will fail if the directory already exists.
    
    Specified by:
    
    mkdir in interface FileSystem
    
    Parameters:
    
    path - path to the file
    
    handler - the handler that will be called on completion
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - mkdirBlocking
```
public FileSystem mkdirBlocking(String path)
```
    Description copied from interface: FileSystem
    
    Blocking version of FileSystem.mkdir(String, Handler)
    
    Specified by:
    
    mkdirBlocking in interface FileSystem
  - mkdirs
```
public FileSystem mkdirs(String path,
                         Handler<AsyncResult<Void>> handler)
```
    Description copied from interface: FileSystem
    
    Create the directory represented by path and any non existent parents, asynchronously.
    The operation will fail if the directory already exists.
    
    Specified by:
    
    mkdirs in interface FileSystem
    
    Parameters:
    
    path - path to the file
    
    handler - the handler that will be called on completion
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - mkdirsBlocking
```
public FileSystem mkdirsBlocking(String path)
```
    Description copied from interface: FileSystem
    
    Blocking version of FileSystem.mkdirs(String, Handler)
    
    Specified by:
    
    mkdirsBlocking in interface FileSystem
  - mkdir
```
public FileSystem mkdir(String path,
                        String perms,
                        Handler<AsyncResult<Void>> handler)
```
    Description copied from interface: FileSystem
    
    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.
    
    Specified by:
    
    mkdir in interface FileSystem
    
    Parameters:
    
    path - path to the file
    
    perms - the permissions string
    
    handler - the handler that will be called on completion
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - mkdirBlocking
```
public FileSystem mkdirBlocking(String path,
                                String perms)
```
    Description copied from interface: FileSystem
    
    Blocking version of FileSystem.mkdir(String, String, Handler)
    
    Specified by:
    
    mkdirBlocking in interface FileSystem
  - mkdirs
```
public FileSystem mkdirs(String path,
                         String perms,
                         Handler<AsyncResult<Void>> handler)
```
    Description copied from interface: FileSystem
    
    Create the directory represented by path and any non existent parents, asynchronously.
    The new directory will be created with permissions as specified by perms.
    The permission String takes the form rwxr-x--- as specified in here.
    The operation will fail if the directory already exists.
    
    Specified by:
    
    mkdirs in interface FileSystem
    
    Parameters:
    
    path - path to the file
    
    perms - the permissions string
    
    handler - the handler that will be called on completion
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - mkdirsBlocking
```
public FileSystem mkdirsBlocking(String path,
                                 String perms)
```
    Description copied from interface: FileSystem
    
    Blocking version of FileSystem.mkdirs(String, String, Handler)
    
    Specified by:
    
    mkdirsBlocking in interface FileSystem
  - readDir
```
public FileSystem readDir(String path,
                          Handler<AsyncResult<List<String>>> handler)
```
    Description copied from interface: FileSystem
    
    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.
    
    Specified by:
    
    readDir in interface FileSystem
    
    Parameters:
    
    path - path to the file
    
    handler - the handler that will be called on completion
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - readDirBlocking
```
public List<String> readDirBlocking(String path)
```
    Description copied from interface: FileSystem
    
    Blocking version of FileSystem.readDir(String, Handler)
    
    Specified by:
    
    readDirBlocking in interface FileSystem
  - readDir
```
public FileSystem readDir(String path,
                          String filter,
                          Handler<AsyncResult<List<String>>> handler)
```
    Description copied from interface: FileSystem
    
    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.
    
    Specified by:
    
    readDir in interface FileSystem
    
    Parameters:
    
    path - path to the directory
    
    filter - the filter expression
    
    handler - the handler that will be called on completion
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - readDirBlocking
```
public List<String> readDirBlocking(String path,
                                    String filter)
```
    Description copied from interface: FileSystem
    
    Blocking version of FileSystem.readDir(String, String, Handler)
    
    Specified by:
    
    readDirBlocking in interface FileSystem
  - readFile
```
public FileSystem readFile(String path,
                           Handler<AsyncResult<Buffer>> handler)
```
    Description copied from interface: FileSystem
    
    Reads the entire file as represented by the path path as a Buffer, asynchronously.
    Do not user this method to read very large files or you risk running out of available RAM.
    
    Specified by:
    
    readFile in interface FileSystem
    
    Parameters:
    
    path - path to the file
    
    handler - the handler that will be called on completion
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - readFileBlocking
```
public Buffer readFileBlocking(String path)
```
    Description copied from interface: FileSystem
    
    Blocking version of FileSystem.readFile(String, Handler)
    
    Specified by:
    
    readFileBlocking in interface FileSystem
  - writeFile
```
public FileSystem writeFile(String path,
                            Buffer data,
                            Handler<AsyncResult<Void>> handler)
```
    Description copied from interface: FileSystem
    
    Creates the file, and writes the specified Buffer data to the file represented by the path path, asynchronously.
    
    Specified by:
    
    writeFile in interface FileSystem
    
    Parameters:
    
    path - path to the file
    
    handler - the handler that will be called on completion
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - writeFileBlocking
```
public FileSystem writeFileBlocking(String path,
                                    Buffer data)
```
    Description copied from interface: FileSystem
    
    Blocking version of FileSystem.writeFile(String, Buffer, Handler)
    
    Specified by:
    
    writeFileBlocking in interface FileSystem
  - open
```
public FileSystem open(String path,
                       OpenOptions options,
                       Handler<AsyncResult<AsyncFile>> handler)
```
    Description copied from interface: FileSystem
    
    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.
    
    Specified by:
    
    open in interface FileSystem
    
    Parameters:
    
    path - path to the file
    
    options - options describing how the file should be opened
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - openBlocking
```
public AsyncFile openBlocking(String path,
                              OpenOptions options)
```
    Description copied from interface: FileSystem
    
    Blocking version of FileSystem.open(String, io.vertx.core.file.OpenOptions, Handler)
    
    Specified by:
    
    openBlocking in interface FileSystem
  - createFile
```
public FileSystem createFile(String path,
                             Handler<AsyncResult<Void>> handler)
```
    Description copied from interface: FileSystem
    
    Creates an empty file with the specified path, asynchronously.
    
    Specified by:
    
    createFile in interface FileSystem
    
    Parameters:
    
    path - path to the file
    
    handler - the handler that will be called on completion
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - createFileBlocking
```
public FileSystem createFileBlocking(String path)
```
    Description copied from interface: FileSystem
    
    Blocking version of FileSystem.createFile(String, Handler)
    
    Specified by:
    
    createFileBlocking in interface FileSystem
  - createFile
```
public FileSystem createFile(String path,
                             String perms,
                             Handler<AsyncResult<Void>> handler)
```
    Description copied from interface: FileSystem
    
    Creates an empty file with the specified path and permissions perms, asynchronously.
    
    Specified by:
    
    createFile in interface FileSystem
    
    Parameters:
    
    path - path to the file
    
    perms - the permissions string
    
    handler - the handler that will be called on completion
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - createFileBlocking
```
public FileSystem createFileBlocking(String path,
                                     String perms)
```
    Description copied from interface: FileSystem
    
    Blocking version of FileSystem.createFile(String, String, Handler)
    
    Specified by:
    
    createFileBlocking in interface FileSystem
  - exists
```
public FileSystem exists(String path,
                         Handler<AsyncResult<Boolean>> handler)
```
    Description copied from interface: FileSystem
    
    Determines whether the file as specified by the path path exists, asynchronously.
    
    Specified by:
    
    exists in interface FileSystem
    
    Parameters:
    
    path - path to the file
    
    handler - the handler that will be called on completion
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - existsBlocking
```
public boolean existsBlocking(String path)
```
    Description copied from interface: FileSystem
    
    Blocking version of FileSystem.exists(String, Handler)
    
    Specified by:
    
    existsBlocking in interface FileSystem
  - fsProps
```
public FileSystem fsProps(String path,
                          Handler<AsyncResult<FileSystemProps>> handler)
```
    Description copied from interface: FileSystem
    
    Returns properties of the file-system being used by the specified path, asynchronously.
    
    Specified by:
    
    fsProps in interface FileSystem
    
    Parameters:
    
    path - path to anywhere on the filesystem
    
    handler - the handler that will be called on completion
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - fsPropsBlocking
```
public FileSystemProps fsPropsBlocking(String path)
```
    Description copied from interface: FileSystem
    
    Blocking version of FileSystem.fsProps(String, Handler)
    
    Specified by:
    
    fsPropsBlocking in interface FileSystem
  - chmodInternal
```
protected FileSystemImpl.BlockingAction<Void> chmodInternal(String path,
                                                            String perms,
                                                            String dirPerms,
                                                            Handler<AsyncResult<Void>> handler)
```
  - chownInternal
```
protected FileSystemImpl.BlockingAction<Void> chownInternal(String path,
                                                            String user,
                                                            String group,
                                                            Handler<AsyncResult<Void>> handler)
```
  - mkdirInternal
```
protected FileSystemImpl.BlockingAction<Void> mkdirInternal(String path,
                                                            String perms,
                                                            boolean createParents,
                                                            Handler<AsyncResult<Void>> handler)
```
  - doOpen
```
protected AsyncFile doOpen(String path,
                           OpenOptions options,
                           ContextImpl context)
```
  - createFileInternal
```
protected FileSystemImpl.BlockingAction<Void> createFileInternal(String p,
                                                                 String perms,
                                                                 Handler<AsyncResult<Void>> handler)
```

Class FileSystemImpl

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

vertx

Constructor Detail

FileSystemImpl

Method Detail

copy

copyBlocking

copyRecursive

copyRecursiveBlocking

move

moveBlocking

truncate

truncateBlocking

chmod

chmodBlocking

chmodRecursive

chmodRecursiveBlocking

chown

chownBlocking

props

propsBlocking

lprops

lpropsBlocking

link

linkBlocking

symlink

symlinkBlocking

unlink

unlinkBlocking

readSymlink

readSymlinkBlocking

delete

deleteBlocking

deleteRecursive

deleteRecursiveBlocking

mkdir

mkdirBlocking

mkdirs

mkdirsBlocking

mkdir

mkdirBlocking

mkdirs

mkdirsBlocking

readDir

readDirBlocking

readDir

readDirBlocking

readFile

readFileBlocking

writeFile

writeFileBlocking

open

openBlocking

createFile

createFileBlocking

createFile

createFileBlocking

exists

existsBlocking

fsProps

fsPropsBlocking

chmodInternal

chownInternal

mkdirInternal

doOpen

createFileInternal