vertx-lang-scala-docs_2.12 3.9.1 API < Back
 

# Packages

-  package root
  Definition Classes
    root
-  package io
  Definition Classes
    root
-  package vertx
  Definition Classes
    io
-  package scala
  Definition Classes
    vertx
-  package core
  Definition Classes
    scala
-  package file
  Definition Classes
    core
- AsyncFile
- CopyOptions
- FileProps
- FileSystem
- FileSystemOptions
- FileSystemProps
- OpenOptions

c

io.vertx.scala.core.file

# FileSystem 

###
Companion object FileSystem

#### class FileSystem extends AnyRef

Contains a broad set of operations for manipulating files on the file system.

A (potential) blocking and non blocking version of each operation is provided.

The non blocking versions take a handler which is called when the operation completes or an error occurs.

The blocking versions are named `xxxBlocking` and return the results, or throw exceptions directly. In many cases, depending on the operating system and file system some of the potentially blocking operations can return quickly, which is why we provide them, but it's highly recommended that you test how long they take to return in your particular application before using them on an event loop.

Please consult the documentation for more information on file system support.

Linear Supertypes
AnyRef, Any
 
Ordering

1. Alphabetic
2. By Inheritance

Inherited

1. FileSystem
2. AnyRef
3. Any

1. Hide All
2. Show All

Visibility

1. Public
2. All

### Instance Constructors

1.  new FileSystem(_asJava: AnyRef)

### Value Members

1.  final def !=(arg0: Any): Boolean
   Definition Classes
     AnyRef → Any
2.  final def ##(): Int
   Definition Classes
     AnyRef → Any
3.  final def ==(arg0: Any): Boolean
   Definition Classes
     AnyRef → Any
4.  final def asInstanceOf[T0]: T0
   Definition Classes
     Any
5.  def asJava: AnyRef
6.  def chmod(path: String, perms: String, handler: Handler[AsyncResult[Unit]]): FileSystem

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

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

   The permission String takes the form rwxr-x--- as specified here. * @param 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

7.  def chmodBlocking(path: String, perms: String): FileSystem

   Blocking version of io.vertx.scala.core.file.FileSystem

8.  def chmodFuture(path: String, perms: String): scala.concurrent.Future[Unit]

   Like chmod but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

9.  def chmodRecursive(path: String, perms: String, dirPerms: String, handler: Handler[AsyncResult[Unit]]): FileSystem

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

   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`. * @param 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

10.  def chmodRecursiveBlocking(path: String, perms: String, dirPerms: String): FileSystem

    Blocking version of io.vertx.scala.core.file.FileSystem#chmodRecursive

11.  def chmodRecursiveFuture(path: String, perms: String, dirPerms: String): scala.concurrent.Future[Unit]

    Like chmodRecursive but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

12.  def chown(path: String, user: Option[String], group: Option[String], handler: Handler[AsyncResult[Unit]]): FileSystem

    Change the ownership on the file represented by `path` to `user` and {code group`, asynchronously. * @param path the path to the file`

    Change the ownership on the file represented by `path` to `user` and {code group`, asynchronously. * @param path the path to the file`

    user

      the user name, `null` will not change the user name

    group

      the user group, `null` will not change the user group name

    handler

      the handler that will be called on completion

    returns

      a reference to this, so the API can be used fluently

13.  def chownBlocking(path: String, user: Option[String], group: Option[String]): FileSystem

    Blocking version of

14.  def chownFuture(path: String, user: Option[String], group: Option[String]): scala.concurrent.Future[Unit]

    Like chown but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

15.  def clone(): AnyRef
    Attributes
      protected[java.lang]
    Definition Classes
      AnyRef
    Annotations
      @native() @throws( ... )
16.  def copy(from: String, to: String, options: CopyOptions, handler: Handler[AsyncResult[Unit]]): FileSystem

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

    Copy a file from the path `from` to path `to`, asynchronously. * @param from the path to copy from

    to

      the path to copy to

    options

      options describing how the file should be copied see CopyOptions

    handler

      the handler that will be called on completion

    returns

      a reference to this, so the API can be used fluently

17.  def copy(from: String, to: String, handler: Handler[AsyncResult[Unit]]): FileSystem

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

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

    The copy will fail if the destination already exists. * @param 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

18.  def copyBlocking(from: String, to: String): FileSystem

    Blocking version of io.vertx.scala.core.file.FileSystem#copy

19.  def copyFuture(from: String, to: String, options: CopyOptions): scala.concurrent.Future[Unit]

    Like copy but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

20.  def copyFuture(from: String, to: String): scala.concurrent.Future[Unit]

    Like copy but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

21.  def copyRecursive(from: String, to: String, recursive: Boolean, handler: Handler[AsyncResult[Unit]]): FileSystem

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

    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. * @param 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

22.  def copyRecursiveBlocking(from: String, to: String, recursive: Boolean): FileSystem

    Blocking version of io.vertx.scala.core.file.FileSystem#copyRecursive

23.  def copyRecursiveFuture(from: String, to: String, recursive: Boolean): scala.concurrent.Future[Unit]

    Like copyRecursive but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

24.  def createFile(path: String, perms: String, handler: Handler[AsyncResult[Unit]]): FileSystem

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

    Creates an empty file with the specified `path` and permissions `perms`, asynchronously. * @param 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

25.  def createFile(path: String, handler: Handler[AsyncResult[Unit]]): FileSystem

    Creates an empty file with the specified `path`, asynchronously.

    Creates an empty file with the specified `path`, asynchronously. * @param 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

26.  def createFileBlocking(path: String, perms: String): FileSystem

    Blocking version of io.vertx.scala.core.file.FileSystem#createFile

27.  def createFileBlocking(path: String): FileSystem

    Blocking version of io.vertx.scala.core.file.FileSystem#createFile

28.  def createFileFuture(path: String, perms: String): scala.concurrent.Future[Unit]

    Like createFile but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

29.  def createFileFuture(path: String): scala.concurrent.Future[Unit]

    Like createFile but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

30.  def createTempDirectory(dir: String, prefix: String, perms: String, handler: Handler[AsyncResult[String]]): FileSystem

    Creates a new directory in the directory provided by the path `path`, using the given prefix to generate its name, asynchronously.

    Creates a new directory in the directory provided by the path `path`, using the given prefix to generate its name, asynchronously.

    The new directory will be created with permissions as specified by `perms`.

    The permission String takes the form rwxr-x--- as specified in here.

    As with the `File.createTempFile` methods, this method is only part of a temporary-file facility.A #addShutdownHook shutdown-hook, or the deleteOnExit mechanism may be used to delete the directory automatically. * @param dir the path to directory in which to create the directory

    prefix

      the prefix string to be used in generating the directory's name; may be `null`

    perms

      the permissions string

    handler

      the handler that will be called on completion

    returns

      a reference to this, so the API can be used fluently

31.  def createTempDirectory(prefix: String, perms: String, handler: Handler[AsyncResult[String]]): FileSystem

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

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

    The new directory will be created with permissions as specified by `perms`.

    The permission String takes the form rwxr-x--- as specified in here.

    As with the `File.createTempFile` methods, this method is only part of a temporary-file facility.A #addShutdownHook shutdown-hook, or the deleteOnExit mechanism may be used to delete the directory automatically. * @param prefix the prefix string to be used in generating the directory's name; may be `null`

    perms

      the permissions string

    handler

      the handler that will be called on completion

    returns

      a reference to this, so the API can be used fluently

32.  def createTempDirectory(prefix: String, handler: Handler[AsyncResult[String]]): FileSystem

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

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

    As with the `File.createTempFile` methods, this method is only part of a temporary-file facility.A #addShutdownHook shutdown-hook, or the deleteOnExit mechanism may be used to delete the directory automatically. * @param prefix the prefix string to be used in generating the directory's name; may be `null`

    handler

      the handler that will be called on completion

    returns

      a reference to this, so the API can be used fluently

33.  def createTempDirectoryBlocking(dir: String, prefix: String, perms: String): String

    Blocking version of io.vertx.scala.core.file.FileSystem#createTempDirectory

34.  def createTempDirectoryBlocking(prefix: String, perms: String): String

    Blocking version of io.vertx.scala.core.file.FileSystem#createTempDirectory

35.  def createTempDirectoryBlocking(prefix: String): String

    Blocking version of io.vertx.scala.core.file.FileSystem#createTempDirectory

36.  def createTempDirectoryFuture(dir: String, prefix: String, perms: String): scala.concurrent.Future[String]

    Like createTempDirectory but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

37.  def createTempDirectoryFuture(prefix: String, perms: String): scala.concurrent.Future[String]

    Like createTempDirectory but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

38.  def createTempDirectoryFuture(prefix: String): scala.concurrent.Future[String]

    Like createTempDirectory but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

39.  def createTempFile(dir: String, prefix: String, suffix: String, perms: String, handler: Handler[AsyncResult[String]]): FileSystem

    Creates a new file in the directory provided by the path `dir`, using the given prefix and suffix to generate its name, asynchronously.

    Creates a new file in the directory provided by the path `dir`, using the given prefix and suffix to generate its name, asynchronously.

    The new directory will be created with permissions as specified by `perms`.

    The permission String takes the form rwxr-x--- as specified in here.

    As with the `File.createTempFile` methods, this method is only part of a temporary-file facility.A #addShutdownHook shutdown-hook, or the deleteOnExit mechanism may be used to delete the directory automatically. * @param dir the path to directory in which to create the directory

    prefix

      the prefix string to be used in generating the directory's name; may be `null`

    suffix

      the suffix string to be used in generating the file's name; may be `null`, in which case "`.tmp`" is used

    perms

      the permissions string

    handler

      the handler that will be called on completion

    returns

      a reference to this, so the API can be used fluently

40.  def createTempFile(prefix: String, suffix: String, perms: String, handler: Handler[AsyncResult[String]]): FileSystem

    Creates a new file in the directory provided by the path `dir`, using the given prefix and suffix to generate its name, asynchronously.

    Creates a new file in the directory provided by the path `dir`, using the given prefix and suffix to generate its name, asynchronously.

    As with the `File.createTempFile` methods, this method is only part of a temporary-file facility.A #addShutdownHook shutdown-hook, or the deleteOnExit mechanism may be used to delete the directory automatically. * @param prefix the prefix string to be used in generating the directory's name; may be `null`

    suffix

      the suffix string to be used in generating the file's name; may be `null`, in which case "`.tmp`" is used

    handler

      the handler that will be called on completion

    returns

      a reference to this, so the API can be used fluently

41.  def createTempFile(prefix: String, suffix: String, handler: Handler[AsyncResult[String]]): FileSystem

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

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

    As with the `File.createTempFile` methods, this method is only part of a temporary-file facility.A #addShutdownHook shutdown-hook, or the deleteOnExit mechanism may be used to delete the directory automatically. * @param prefix the prefix string to be used in generating the directory's name; may be `null`

    suffix

      the suffix string to be used in generating the file's name; may be `null`, in which case "`.tmp`" is used

    handler

      the handler that will be called on completion

    returns

      a reference to this, so the API can be used fluently

42.  def createTempFileBlocking(dir: String, prefix: String, suffix: String, perms: String): String

    Blocking version of io.vertx.scala.core.file.FileSystem#createTempFile

43.  def createTempFileBlocking(prefix: String, suffix: String, perms: String): String

    Blocking version of io.vertx.scala.core.file.FileSystem#createTempFile

44.  def createTempFileBlocking(prefix: String, suffix: String): String

    Blocking version of io.vertx.scala.core.file.FileSystem#createTempFile

45.  def createTempFileFuture(dir: String, prefix: String, suffix: String, perms: String): scala.concurrent.Future[String]

    Like createTempFile but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

46.  def createTempFileFuture(prefix: String, suffix: String, perms: String): scala.concurrent.Future[String]

    Like createTempFile but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

47.  def createTempFileFuture(prefix: String, suffix: String): scala.concurrent.Future[String]

    Like createTempFile but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

48.  def delete(path: String, handler: Handler[AsyncResult[Unit]]): FileSystem

    Deletes the file represented by the specified `path`, asynchronously.

    Deletes the file represented by the specified `path`, asynchronously. * @param 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

49.  def deleteBlocking(path: String): FileSystem

    Blocking version of io.vertx.scala.core.file.FileSystem#delete

50.  def deleteFuture(path: String): scala.concurrent.Future[Unit]

    Like delete but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

51.  def deleteRecursive(path: String, recursive: Boolean, handler: Handler[AsyncResult[Unit]]): FileSystem

    Deletes the file represented by the specified `path`, asynchronously.

    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. * @param 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

52.  def deleteRecursiveBlocking(path: String, recursive: Boolean): FileSystem

    Blocking version of io.vertx.scala.core.file.FileSystem#deleteRecursive

53.  def deleteRecursiveFuture(path: String, recursive: Boolean): scala.concurrent.Future[Unit]

    Like deleteRecursive but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

54.  final def eq(arg0: AnyRef): Boolean
    Definition Classes
      AnyRef
55.  def equals(arg0: Any): Boolean
    Definition Classes
      AnyRef → Any
56.  def exists(path: String, handler: Handler[AsyncResult[Boolean]]): FileSystem

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

    Determines whether the file as specified by the path `path` exists, asynchronously. * @param 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

57.  def existsBlocking(path: String): Boolean

    Blocking version of io.vertx.scala.core.file.FileSystem#exists

58.  def existsFuture(path: String): scala.concurrent.Future[Boolean]

    Like exists but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

59.  def finalize(): Unit
    Attributes
      protected[java.lang]
    Definition Classes
      AnyRef
    Annotations
      @throws( classOf[java.lang.Throwable] )
60.  def fsProps(path: String, handler: Handler[AsyncResult[FileSystemProps]]): FileSystem

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

    Returns properties of the file-system being used by the specified `path`, asynchronously. * @param 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

61.  def fsPropsBlocking(path: String): FileSystemProps

    Blocking version of io.vertx.scala.core.file.FileSystem#fsProps

62.  def fsPropsFuture(path: String): scala.concurrent.Future[FileSystemProps]

    Like fsProps but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

63.  final def getClass(): Class[_]
    Definition Classes
      AnyRef → Any
    Annotations
      @native()
64.  def hashCode(): Int
    Definition Classes
      AnyRef → Any
    Annotations
      @native()
65.  final def isInstanceOf[T0]: Boolean
    Definition Classes
      Any
66.  def link(link: String, existing: String, handler: Handler[AsyncResult[Unit]]): FileSystem

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

    Create a hard link on the file system from `link` to `existing`, asynchronously. * @param 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

67.  def linkBlocking(link: String, existing: String): FileSystem

    Blocking version of io.vertx.scala.core.file.FileSystem#link

68.  def linkFuture(link: String, existing: String): scala.concurrent.Future[Unit]

    Like link but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

69.  def lprops(path: String, handler: Handler[AsyncResult[FileProps]]): FileSystem

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

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

    The link will not be followed. * @param 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

70.  def lpropsBlocking(path: String): FileProps

    Blocking version of io.vertx.scala.core.file.FileSystem#lprops

71.  def lpropsFuture(path: String): scala.concurrent.Future[FileProps]

    Like lprops but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

72.  def mkdir(path: String, perms: String, handler: Handler[AsyncResult[Unit]]): FileSystem

    Create the directory represented by `path`, asynchronously.

    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. * @param 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

73.  def mkdir(path: String, handler: Handler[AsyncResult[Unit]]): FileSystem

    Create the directory represented by `path`, asynchronously.

    Create the directory represented by `path`, asynchronously.

    The operation will fail if the directory already exists. * @param 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

74.  def mkdirBlocking(path: String, perms: String): FileSystem

    Blocking version of io.vertx.scala.core.file.FileSystem#mkdir

75.  def mkdirBlocking(path: String): FileSystem

    Blocking version of io.vertx.scala.core.file.FileSystem#mkdir

76.  def mkdirFuture(path: String, perms: String): scala.concurrent.Future[Unit]

    Like mkdir but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

77.  def mkdirFuture(path: String): scala.concurrent.Future[Unit]

    Like mkdir but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

78.  def mkdirs(path: String, perms: String, handler: Handler[AsyncResult[Unit]]): FileSystem

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

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

    The new directory will be created with permissions as specified by `perms`.

    The permission String takes the form rwxr-x--- as specified in here.

    The operation will fail if the `path` already exists but is not a directory. * @param 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

79.  def mkdirs(path: String, handler: Handler[AsyncResult[Unit]]): FileSystem

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

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

    The operation will fail if the `path` already exists but is not a directory. * @param 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

80.  def mkdirsBlocking(path: String, perms: String): FileSystem

    Blocking version of io.vertx.scala.core.file.FileSystem#mkdirs

81.  def mkdirsBlocking(path: String): FileSystem

    Blocking version of io.vertx.scala.core.file.FileSystem#mkdirs

82.  def mkdirsFuture(path: String, perms: String): scala.concurrent.Future[Unit]

    Like mkdirs but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

83.  def mkdirsFuture(path: String): scala.concurrent.Future[Unit]

    Like mkdirs but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

84.  def move(from: String, to: String, options: CopyOptions, handler: Handler[AsyncResult[Unit]]): FileSystem

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

    Move a file from the path `from` to path `to`, asynchronously. * @param from the path to copy from

    to

      the path to copy to

    options

      options describing how the file should be copied see CopyOptions

    handler

      the handler that will be called on completion

    returns

      a reference to this, so the API can be used fluently

85.  def move(from: String, to: String, handler: Handler[AsyncResult[Unit]]): FileSystem

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

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

    The move will fail if the destination already exists. * @param 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

86.  def moveBlocking(from: String, to: String): FileSystem

    Blocking version of io.vertx.scala.core.file.FileSystem#move

87.  def moveFuture(from: String, to: String, options: CopyOptions): scala.concurrent.Future[Unit]

    Like move but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

88.  def moveFuture(from: String, to: String): scala.concurrent.Future[Unit]

    Like move but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

89.  final def ne(arg0: AnyRef): Boolean
    Definition Classes
      AnyRef
90.  final def notify(): Unit
    Definition Classes
      AnyRef
    Annotations
      @native()
91.  final def notifyAll(): Unit
    Definition Classes
      AnyRef
    Annotations
      @native()
92.  def open(path: String, options: OpenOptions, handler: Handler[AsyncResult[AsyncFile]]): FileSystem

    Open the file represented by `path`, asynchronously.

    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. * @param path path to the file

    options

      options describing how the file should be opened see OpenOptions

    returns

      a reference to this, so the API can be used fluently

93.  def openBlocking(path: String, options: OpenOptions): AsyncFile

    Blocking version of io.vertx.scala.core.file.FileSystem#open

94.  def openFuture(path: String, options: OpenOptions): scala.concurrent.Future[AsyncFile]

    Like open but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

95.  def props(path: String, handler: Handler[AsyncResult[FileProps]]): FileSystem

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

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

    If the file is a link, the link will be followed. * @param 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

96.  def propsBlocking(path: String): FileProps

    Blocking version of io.vertx.scala.core.file.FileSystem#props

97.  def propsFuture(path: String): scala.concurrent.Future[FileProps]

    Like props but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

98.  def readDir(path: String, filter: String, handler: Handler[AsyncResult[Buffer[String]]]): FileSystem

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

    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. * @param 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

99.  def readDir(path: String, handler: Handler[AsyncResult[Buffer[String]]]): FileSystem

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

    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. * @param 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

100.  def readDirBlocking(path: String, filter: String): Buffer[String]

     Blocking version of io.vertx.scala.core.file.FileSystem#readDir

101.  def readDirBlocking(path: String): Buffer[String]

     Blocking version of io.vertx.scala.core.file.FileSystem#readDir

102.  def readDirFuture(path: String, filter: String): scala.concurrent.Future[Buffer[String]]

     Like readDir but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

103.  def readDirFuture(path: String): scala.concurrent.Future[Buffer[String]]

     Like readDir but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

104.  def readFile(path: String, handler: Handler[AsyncResult[Buffer]]): FileSystem

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

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

     Do not use this method to read very large files or you risk running out of available RAM. * @param 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

105.  def readFileBlocking(path: String): Buffer

     Blocking version of io.vertx.scala.core.file.FileSystem#readFile

106.  def readFileFuture(path: String): scala.concurrent.Future[Buffer]

     Like readFile but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

107.  def readSymlink(link: String, handler: Handler[AsyncResult[String]]): FileSystem

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

     Returns the path representing the file that the symbolic link specified by `link` points to, asynchronously. * @param link the link

     handler

       the handler that will be called on completion

     returns

       a reference to this, so the API can be used fluently

108.  def readSymlinkBlocking(link: String): String

     Blocking version of io.vertx.scala.core.file.FileSystem#readSymlink

109.  def readSymlinkFuture(link: String): scala.concurrent.Future[String]

     Like readSymlink but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

110.  def symlink(link: String, existing: String, handler: Handler[AsyncResult[Unit]]): FileSystem

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

     Create a symbolic link on the file system from `link` to `existing`, asynchronously. * @param 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

111.  def symlinkBlocking(link: String, existing: String): FileSystem

     Blocking version of io.vertx.scala.core.file.FileSystem#link

112.  def symlinkFuture(link: String, existing: String): scala.concurrent.Future[Unit]

     Like symlink but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

113.  final def synchronized[T0](arg0: ⇒ T0): T0
     Definition Classes
       AnyRef
114.  def toString(): String
     Definition Classes
       AnyRef → Any
115.  def truncate(path: String, len: Long, handler: Handler[AsyncResult[Unit]]): FileSystem

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

     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`. * @param 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

116.  def truncateBlocking(path: String, len: Long): FileSystem

     Blocking version of io.vertx.scala.core.file.FileSystem#truncate

117.  def truncateFuture(path: String, len: Long): scala.concurrent.Future[Unit]

     Like truncate but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

118.  def unlink(link: String, handler: Handler[AsyncResult[Unit]]): FileSystem

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

     Unlinks the link on the file system represented by the path `link`, asynchronously. * @param link the link

     handler

       the handler that will be called on completion

     returns

       a reference to this, so the API can be used fluently

119.  def unlinkBlocking(link: String): FileSystem

     Blocking version of io.vertx.scala.core.file.FileSystem#unlink

120.  def unlinkFuture(link: String): scala.concurrent.Future[Unit]

     Like unlink but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

121.  final def wait(): Unit
     Definition Classes
       AnyRef
     Annotations
       @throws( ... )
122.  final def wait(arg0: Long, arg1: Int): Unit
     Definition Classes
       AnyRef
     Annotations
       @throws( ... )
123.  final def wait(arg0: Long): Unit
     Definition Classes
       AnyRef
     Annotations
       @native() @throws( ... )
124.  def writeFile(path: String, data: Buffer, handler: Handler[AsyncResult[Unit]]): FileSystem

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

     Creates the file, and writes the specified `Buffer data` to the file represented by the path `path`, asynchronously. * @param 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

125.  def writeFileBlocking(path: String, data: Buffer): FileSystem

     Blocking version of io.vertx.scala.core.file.FileSystem#writeFile

126.  def writeFileFuture(path: String, data: Buffer): scala.concurrent.Future[Unit]

     Like writeFile but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

### Inherited from AnyRef

### Inherited from Any

### Ungrouped