Packages

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.

    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.

    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#chmodRecursiveFuture

  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.

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

    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.

    from

    the path to copy from

    to

    the path to copy to

    options

    options describing how the file should be copiedsee 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.

    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#copyFuture

  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.

    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#copyRecursiveFuture

  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.

    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.

    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#createFileFuture

  27. def createFileBlocking(path: String): FileSystem

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

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

    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

  31. def deleteBlocking(path: String): FileSystem

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

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

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

  33. 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.

    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

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

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

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

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

  36. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  37. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  38. 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.

    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

  39. def existsBlocking(path: String): Boolean

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

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

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

  41. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  42. 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.

    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

  43. def fsPropsBlocking(path: String): FileSystemProps

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

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

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

  45. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  46. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  47. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  48. 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.

    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

  49. def linkBlocking(link: String, existing: String): FileSystem

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

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

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

  51. 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.

    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

  52. def lpropsBlocking(path: String): FileProps

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

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

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

  54. 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.

    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

  55. 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.

    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

  56. def mkdirBlocking(path: String, perms: String): FileSystem

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

  57. def mkdirBlocking(path: String): FileSystem

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

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

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

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

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

  60. 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 directory already exists.

    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

  61. 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 directory already exists.

    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

  62. def mkdirsBlocking(path: String, perms: String): FileSystem

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

  63. def mkdirsBlocking(path: String): FileSystem

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

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

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

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

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

  66. 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.

    from

    the path to copy from

    to

    the path to copy to

    options

    options describing how the file should be copiedsee CopyOptions

    handler

    the handler that will be called on completion

    returns

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

  67. 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.

    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

  68. def moveBlocking(from: String, to: String): FileSystem

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

  69. 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.

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

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

  71. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  72. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  73. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  74. 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.

    path

    path to the file

    options

    options describing how the file should be openedsee OpenOptions

    returns

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

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

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

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

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

  77. 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.

    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

  78. def propsBlocking(path: String): FileProps

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

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

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

  80. 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 @{filterwill be returned.

    The result is an array of String representing the paths of the files inside the directory.

    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

  81. 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.

    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

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

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

  83. def readDirBlocking(path: String): Buffer[String]

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

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

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

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

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

  86. 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.

    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

  87. def readFileBlocking(path: String): Buffer

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

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

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

  89. 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.

    link

    the link

    handler

    the handler that will be called on completion

    returns

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

  90. def readSymlinkBlocking(link: String): String

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

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

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

  92. 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.

    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

  93. def symlinkBlocking(link: String, existing: String): FileSystem

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

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

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

  95. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  96. def toString(): String
    Definition Classes
    AnyRef → Any
  97. 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.

    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

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

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

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

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

  100. 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.

    link

    the link

    handler

    the handler that will be called on completion

    returns

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

  101. def unlinkBlocking(link: String): FileSystem

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

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

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

  103. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  104. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  105. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @throws( ... )
  106. 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.

    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

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

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

  108. 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