Class List Method List File List

# Class: Vertx::FileSystem

Inherits:
  Object
  - Object
  - Vertx::FileSystem
  show all
Defined in:
  /Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb

## Overview

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.

## Constant Summary

@@j_api_type =

      Object.new

## Class Method Summary (collapse)

- + (Boolean) accept?(obj)
- + (Object) j_api_type
- + (Object) j_class
- + (Object) unwrap(obj)
- + (Object) wrap(obj)

## Instance Method Summary (collapse)

- - (self) chmod(path = nil, perms = nil) { ... }
  Change the permissions on the file represented by path to perms, asynchronously.
- - (self) chmod_blocking(path = nil, perms = nil)
  Blocking version of String, Handler).
- - (self) chmod_recursive(path = nil, perms = nil, dirPerms = nil) { ... }
  Change the permissions on the file represented by path to perms, asynchronously.
- - (self) chmod_recursive_blocking(path = nil, perms = nil, dirPerms = nil)
  Blocking version of #chmod_recursive.
- - (self) chown(path = nil, user = nil, group = nil) { ... }
  Change the ownership on the file represented by path to user and group, asynchronously.
- - (self) chown_blocking(path = nil, user = nil, group = nil)
  Blocking version of.
- - (self) copy(from = nil, to = nil, options = nil) { ... }
  Copy a file from the path from to path to, asynchronously.
- - (self) copy_blocking(from = nil, to = nil)
  Blocking version of #copy.
- - (self) copy_recursive(from = nil, to = nil, recursive = nil) { ... }
  Copy a file from the path from to path to, asynchronously.
- - (self) copy_recursive_blocking(from = nil, to = nil, recursive = nil)
  Blocking version of #copy_recursive.
- - (self) create_file(path = nil, perms = nil) { ... }
  Creates an empty file with the specified path and permissions perms, asynchronously.
- - (self) create_file_blocking(path = nil, perms = nil)
  Blocking version of #create_file.
- - (self) delete(path = nil) { ... }
  Deletes the file represented by the specified path, asynchronously.
- - (self) delete_blocking(path = nil)
  Blocking version of #delete.
- - (self) delete_recursive(path = nil, recursive = nil) { ... }
  Deletes the file represented by the specified path, asynchronously.
- - (self) delete_recursive_blocking(path = nil, recursive = nil)
  Blocking version of #delete_recursive.
- - (self) exists(path = nil) { ... }
  Determines whether the file as specified by the path path exists, asynchronously.
- - (true, false) exists_blocking?(path = nil)
  Blocking version of #exists.
- - (self) fs_props(path = nil) { ... }
  Returns properties of the file-system being used by the specified path, asynchronously.
- - (::Vertx::FileSystemProps) fs_props_blocking(path = nil)
  Blocking version of #fs_props.
- - (self) link(link = nil, existing = nil) { ... }
  Create a hard link on the file system from link to existing, asynchronously.
- - (self) link_blocking(link = nil, existing = nil)
  Blocking version of #link.
- - (self) lprops(path = nil) { ... }
  Obtain properties for the link represented by path, asynchronously.
- - (::Vertx::FileProps) lprops_blocking(path = nil)
  Blocking version of #lprops.
- - (self) mkdir(path = nil, perms = nil) { ... }
  Create the directory represented by path, asynchronously.
- - (self) mkdir_blocking(path = nil, perms = nil)
  Blocking version of #mkdir.
- - (self) mkdirs(path = nil, perms = nil) { ... }
  Create the directory represented by path and any non existent parents, asynchronously.
- - (self) mkdirs_blocking(path = nil, perms = nil)
  Blocking version of #mkdirs.
- - (self) move(from = nil, to = nil, options = nil) { ... }
  Move a file from the path from to path to, asynchronously.
- - (self) move_blocking(from = nil, to = nil)
  Blocking version of #move.
- - (self) open(path = nil, options = nil) { ... }
  Open the file represented by path, asynchronously.
- - (::Vertx::AsyncFile) open_blocking(path = nil, options = nil)
  Blocking version of #open.
- - (self) props(path = nil) { ... }
  Obtain properties for the file represented by path, asynchronously.
- - (::Vertx::FileProps) props_blocking(path = nil)
  Blocking version of #props.
- - (self) read_dir(path = nil, filter = nil) { ... }
  Read the contents of the directory specified by path, asynchronously.
- - (Array<String>) read_dir_blocking(path = nil, filter = nil)
  Blocking version of #read_dir.
- - (self) read_file(path = nil) { ... }
  Reads the entire file as represented by the path path as a , asynchronously.
- - (::Vertx::Buffer) read_file_blocking(path = nil)
  Blocking version of #read_file.
- - (self) read_symlink(link = nil) { ... }
  Returns the path representing the file that the symbolic link specified by link points to, asynchronously.
- - (String) read_symlink_blocking(link = nil)
  Blocking version of #read_symlink.
- - (self) symlink(link = nil, existing = nil) { ... }
  Create a symbolic link on the file system from link to existing, asynchronously.
- - (self) symlink_blocking(link = nil, existing = nil)
  Blocking version of #link.
- - (self) truncate(path = nil, len = nil) { ... }
  Truncate the file represented by path to length len in bytes, asynchronously.
- - (self) truncate_blocking(path = nil, len = nil)
  Blocking version of #truncate.
- - (self) unlink(link = nil) { ... }
  Unlinks the link on the file system represented by the path link, asynchronously.
- - (self) unlink_blocking(link = nil)
  Blocking version of #unlink.
- - (self) write_file(path = nil, data = nil) { ... }
  Creates the file, and writes the specified Buffer data to the file represented by the path path, asynchronously.
- - (self) write_file_blocking(path = nil, data = nil)
  Blocking version of #write_file.

## Class Method Details

### + (`Boolean`) accept?(obj)

Returns:

- (`Boolean`)

    32
    33
    34
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 32

    def @@j_api_type.accept?(obj)
      obj.class == FileSystem
    end

### + (`Object`) j_api_type

    41
    42
    43
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 41

    def self.j_api_type
      @@j_api_type
    end

### + (`Object`) j_class

    44
    45
    46
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 44

    def self.j_class
      Java::IoVertxCoreFile::FileSystem.java_class
    end

### + (`Object`) unwrap(obj)

    38
    39
    40
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 38

    def @@j_api_type.unwrap(obj)
      obj.j_del
    end

### + (`Object`) wrap(obj)

    35
    36
    37
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 35

    def @@j_api_type.wrap(obj)
      FileSystem.new(obj)
    end

## Instance Method Details

### - (`self`) chmod(path = nil, perms = nil) { ... }

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

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

Parameters:

- path (`String`) (defaults to: `nil`) —
  the path to the file
- perms (`String`) (defaults to: `nil`) —
  the permissions string

Yields:

- the handler that will be called on completion

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    164
    165
    166
    167
    168
    169
    170
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 164

    def chmod(path=nil,perms=nil)
      if path.class == String && perms.class == String && block_given?
        @j_del.java_method(:chmod, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(path,perms,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling chmod(#{path},#{perms})"
    end

### - (`self`) chmod_blocking(path = nil, perms = nil)

Blocking version of String, Handler)

Parameters:

- path (`String`) (defaults to: `nil`)
- perms (`String`) (defaults to: `nil`)

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    175
    176
    177
    178
    179
    180
    181
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 175

    def chmod_blocking(path=nil,perms=nil)
      if path.class == String && perms.class == String && !block_given?
        @j_del.java_method(:chmodBlocking, [Java::java.lang.String.java_class,Java::java.lang.String.java_class]).call(path,perms)
        return self
      end
      raise ArgumentError, "Invalid arguments when calling chmod_blocking(#{path},#{perms})"
    end

### - (`self`) chmod_recursive(path = nil, perms = nil, dirPerms = nil) { ... }

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

The permission String takes the form rwxr-x--- as specified in http://download.oracle.com/javase/7/docs/api/java/nio/file/attribute/PosixFilePermissions.html.

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

Parameters:

- path (`String`) (defaults to: `nil`) —
  the path to the file
- perms (`String`) (defaults to: `nil`) —
  the permissions string
- dirPerms (`String`) (defaults to: `nil`) —
  the directory permissions

Yields:

- the handler that will be called on completion

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    193
    194
    195
    196
    197
    198
    199
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 193

    def chmod_recursive(path=nil,perms=nil,dirPerms=nil)
      if path.class == String && perms.class == String && dirPerms.class == String && block_given?
        @j_del.java_method(:chmodRecursive, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(path,perms,dirPerms,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling chmod_recursive(#{path},#{perms},#{dirPerms})"
    end

### - (`self`) chmod_recursive_blocking(path = nil, perms = nil, dirPerms = nil)

Blocking version of #chmod_recursive

Parameters:

- path (`String`) (defaults to: `nil`)
- perms (`String`) (defaults to: `nil`)
- dirPerms (`String`) (defaults to: `nil`)

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    205
    206
    207
    208
    209
    210
    211
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 205

    def chmod_recursive_blocking(path=nil,perms=nil,dirPerms=nil)
      if path.class == String && perms.class == String && dirPerms.class == String && !block_given?
        @j_del.java_method(:chmodRecursiveBlocking, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::java.lang.String.java_class]).call(path,perms,dirPerms)
        return self
      end
      raise ArgumentError, "Invalid arguments when calling chmod_recursive_blocking(#{path},#{perms},#{dirPerms})"
    end

### - (`self`) chown(path = nil, user = nil, group = nil) { ... }

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

Parameters:

- path (`String`) (defaults to: `nil`) —
  the path to the file
- user (`String`) (defaults to: `nil`) —
  the user name, `null` will not change the user name
- group (`String`) (defaults to: `nil`) —
  the user group, `null` will not change the user group name

Yields:

- the handler that will be called on completion

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    218
    219
    220
    221
    222
    223
    224
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 218

    def chown(path=nil,user=nil,group=nil)
      if path.class == String && user.class == String && group.class == String && block_given?
        @j_del.java_method(:chown, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(path,user,group,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling chown(#{path},#{user},#{group})"
    end

### - (`self`) chown_blocking(path = nil, user = nil, group = nil)

Blocking version of

Parameters:

- path (`String`) (defaults to: `nil`)
- user (`String`) (defaults to: `nil`)
- group (`String`) (defaults to: `nil`)

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    231
    232
    233
    234
    235
    236
    237
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 231

    def chown_blocking(path=nil,user=nil,group=nil)
      if path.class == String && user.class == String && group.class == String && !block_given?
        @j_del.java_method(:chownBlocking, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::java.lang.String.java_class]).call(path,user,group)
        return self
      end
      raise ArgumentError, "Invalid arguments when calling chown_blocking(#{path},#{user},#{group})"
    end

### - (`self`) copy(from = nil, to = nil, options = nil) { ... }

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

Parameters:

- from (`String`) (defaults to: `nil`) —
  the path to copy from
- to (`String`) (defaults to: `nil`) —
  the path to copy to
- options (`Hash`) (defaults to: `nil`) —
  options describing how the file should be copied

Yields:

- the handler that will be called on completion

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 53

    def copy(from=nil,to=nil,options=nil)
      if from.class == String && to.class == String && block_given? && options == nil
        @j_del.java_method(:copy, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(from,to,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      elsif from.class == String && to.class == String && options.class == Hash && block_given?
        @j_del.java_method(:copy, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCoreFile::CopyOptions.java_class,Java::IoVertxCore::Handler.java_class]).call(from,to,Java::IoVertxCoreFile::CopyOptions.new(::Vertx::Util::Utils.to_json_object(options)),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling copy(#{from},#{to},#{options})"
    end

### - (`self`) copy_blocking(from = nil, to = nil)

Blocking version of #copy

Parameters:

- from (`String`) (defaults to: `nil`)
- to (`String`) (defaults to: `nil`)

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    67
    68
    69
    70
    71
    72
    73
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 67

    def copy_blocking(from=nil,to=nil)
      if from.class == String && to.class == String && !block_given?
        @j_del.java_method(:copyBlocking, [Java::java.lang.String.java_class,Java::java.lang.String.java_class]).call(from,to)
        return self
      end
      raise ArgumentError, "Invalid arguments when calling copy_blocking(#{from},#{to})"
    end

### - (`self`) copy_recursive(from = nil, to = nil, recursive = nil) { ... }

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.

Parameters:

- from (`String`) (defaults to: `nil`) —
  the path to copy from
- to (`String`) (defaults to: `nil`) —
  the path to copy to
- recursive (`true`, `false`) (defaults to: `nil`)

Yields:

- the handler that will be called on completion

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    85
    86
    87
    88
    89
    90
    91
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 85

    def copy_recursive(from=nil,to=nil,recursive=nil)
      if from.class == String && to.class == String && (recursive.class == TrueClass || recursive.class == FalseClass) && block_given?
        @j_del.java_method(:copyRecursive, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::boolean.java_class,Java::IoVertxCore::Handler.java_class]).call(from,to,recursive,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling copy_recursive(#{from},#{to},#{recursive})"
    end

### - (`self`) copy_recursive_blocking(from = nil, to = nil, recursive = nil)

Blocking version of #copy_recursive

Parameters:

- from (`String`) (defaults to: `nil`)
- to (`String`) (defaults to: `nil`)
- recursive (`true`, `false`) (defaults to: `nil`)

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    97
    98
    99
    100
    101
    102
    103
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 97

    def copy_recursive_blocking(from=nil,to=nil,recursive=nil)
      if from.class == String && to.class == String && (recursive.class == TrueClass || recursive.class == FalseClass) && !block_given?
        @j_del.java_method(:copyRecursiveBlocking, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::boolean.java_class]).call(from,to,recursive)
        return self
      end
      raise ArgumentError, "Invalid arguments when calling copy_recursive_blocking(#{from},#{to},#{recursive})"
    end

### - (`self`) create_file(path = nil, perms = nil) { ... }

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

Parameters:

- path (`String`) (defaults to: `nil`) —
  path to the file
- perms (`String`) (defaults to: `nil`) —
  the permissions string

Yields:

- the handler that will be called on completion

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    595
    596
    597
    598
    599
    600
    601
    602
    603
    604
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 595

    def create_file(path=nil,perms=nil)
      if path.class == String && block_given? && perms == nil
        @j_del.java_method(:createFile, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(path,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      elsif path.class == String && perms.class == String && block_given?
        @j_del.java_method(:createFile, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(path,perms,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling create_file(#{path},#{perms})"
    end

### - (`self`) create_file_blocking(path = nil, perms = nil)

Blocking version of #create_file

Parameters:

- path (`String`) (defaults to: `nil`)
- perms (`String`) (defaults to: `nil`)

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    609
    610
    611
    612
    613
    614
    615
    616
    617
    618
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 609

    def create_file_blocking(path=nil,perms=nil)
      if path.class == String && !block_given? && perms == nil
        @j_del.java_method(:createFileBlocking, [Java::java.lang.String.java_class]).call(path)
        return self
      elsif path.class == String && perms.class == String && !block_given?
        @j_del.java_method(:createFileBlocking, [Java::java.lang.String.java_class,Java::java.lang.String.java_class]).call(path,perms)
        return self
      end
      raise ArgumentError, "Invalid arguments when calling create_file_blocking(#{path},#{perms})"
    end

### - (`self`) delete(path = nil) { ... }

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

Parameters:

- path (`String`) (defaults to: `nil`) —
  path to the file

Yields:

- the handler that will be called on completion

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    373
    374
    375
    376
    377
    378
    379
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 373

    def delete(path=nil)
      if path.class == String && block_given?
        @j_del.java_method(:delete, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(path,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling delete(#{path})"
    end

### - (`self`) delete_blocking(path = nil)

Blocking version of #delete

Parameters:

- path (`String`) (defaults to: `nil`)

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    383
    384
    385
    386
    387
    388
    389
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 383

    def delete_blocking(path=nil)
      if path.class == String && !block_given?
        @j_del.java_method(:deleteBlocking, [Java::java.lang.String.java_class]).call(path)
        return self
      end
      raise ArgumentError, "Invalid arguments when calling delete_blocking(#{path})"
    end

### - (`self`) delete_recursive(path = nil, recursive = nil) { ... }

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.

Parameters:

- path (`String`) (defaults to: `nil`) —
  path to the file
- recursive (`true`, `false`) (defaults to: `nil`) —
  delete recursively?

Yields:

- the handler that will be called on completion

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    398
    399
    400
    401
    402
    403
    404
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 398

    def delete_recursive(path=nil,recursive=nil)
      if path.class == String && (recursive.class == TrueClass || recursive.class == FalseClass) && block_given?
        @j_del.java_method(:deleteRecursive, [Java::java.lang.String.java_class,Java::boolean.java_class,Java::IoVertxCore::Handler.java_class]).call(path,recursive,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling delete_recursive(#{path},#{recursive})"
    end

### - (`self`) delete_recursive_blocking(path = nil, recursive = nil)

Blocking version of #delete_recursive

Parameters:

- path (`String`) (defaults to: `nil`)
- recursive (`true`, `false`) (defaults to: `nil`)

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    409
    410
    411
    412
    413
    414
    415
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 409

    def delete_recursive_blocking(path=nil,recursive=nil)
      if path.class == String && (recursive.class == TrueClass || recursive.class == FalseClass) && !block_given?
        @j_del.java_method(:deleteRecursiveBlocking, [Java::java.lang.String.java_class,Java::boolean.java_class]).call(path,recursive)
        return self
      end
      raise ArgumentError, "Invalid arguments when calling delete_recursive_blocking(#{path},#{recursive})"
    end

### - (`self`) exists(path = nil) { ... }

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

Parameters:

- path (`String`) (defaults to: `nil`) —
  path to the file

Yields:

- the handler that will be called on completion

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    623
    624
    625
    626
    627
    628
    629
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 623

    def exists(path=nil)
      if path.class == String && block_given?
        @j_del.java_method(:exists, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(path,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling exists(#{path})"
    end

### - (`true`, `false`) exists_blocking?(path = nil)

Blocking version of #exists

Parameters:

- path (`String`) (defaults to: `nil`)

Returns:

- (`true`, `false`)

Raises:

- (`ArgumentError`)

    633
    634
    635
    636
    637
    638
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 633

    def exists_blocking?(path=nil)
      if path.class == String && !block_given?
        return @j_del.java_method(:existsBlocking, [Java::java.lang.String.java_class]).call(path)
      end
      raise ArgumentError, "Invalid arguments when calling exists_blocking?(#{path})"
    end

### - (`self`) fs_props(path = nil) { ... }

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

Parameters:

- path (`String`) (defaults to: `nil`) —
  path to anywhere on the filesystem

Yields:

- the handler that will be called on completion

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    643
    644
    645
    646
    647
    648
    649
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 643

    def fs_props(path=nil)
      if path.class == String && block_given?
        @j_del.java_method(:fsProps, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(path,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ::Vertx::Util::Utils.safe_create(ar.result,::Vertx::FileSystemProps) : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling fs_props(#{path})"
    end

### - (`::Vertx::FileSystemProps`) fs_props_blocking(path = nil)

Blocking version of #fs_props

Parameters:

- path (`String`) (defaults to: `nil`)

Returns:

- (`::Vertx::FileSystemProps`)

Raises:

- (`ArgumentError`)

    653
    654
    655
    656
    657
    658
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 653

    def fs_props_blocking(path=nil)
      if path.class == String && !block_given?
        return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:fsPropsBlocking, [Java::java.lang.String.java_class]).call(path),::Vertx::FileSystemProps)
      end
      raise ArgumentError, "Invalid arguments when calling fs_props_blocking(#{path})"
    end

### - (`self`) link(link = nil, existing = nil) { ... }

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

Parameters:

- link (`String`) (defaults to: `nil`) —
  the link
- existing (`String`) (defaults to: `nil`) —
  the link destination

Yields:

- the handler that will be called on completion

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    287
    288
    289
    290
    291
    292
    293
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 287

    def link(link=nil,existing=nil)
      if link.class == String && existing.class == String && block_given?
        @j_del.java_method(:link, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(link,existing,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling link(#{link},#{existing})"
    end

### - (`self`) link_blocking(link = nil, existing = nil)

Blocking version of #link

Parameters:

- link (`String`) (defaults to: `nil`)
- existing (`String`) (defaults to: `nil`)

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    298
    299
    300
    301
    302
    303
    304
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 298

    def link_blocking(link=nil,existing=nil)
      if link.class == String && existing.class == String && !block_given?
        @j_del.java_method(:linkBlocking, [Java::java.lang.String.java_class,Java::java.lang.String.java_class]).call(link,existing)
        return self
      end
      raise ArgumentError, "Invalid arguments when calling link_blocking(#{link},#{existing})"
    end

### - (`self`) lprops(path = nil) { ... }

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

The link will not be followed.

Parameters:

- path (`String`) (defaults to: `nil`) —
  the path to the file

Yields:

- the handler that will be called on completion

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    266
    267
    268
    269
    270
    271
    272
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 266

    def lprops(path=nil)
      if path.class == String && block_given?
        @j_del.java_method(:lprops, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(path,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ::Vertx::Util::Utils.safe_create(ar.result,::Vertx::FileProps) : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling lprops(#{path})"
    end

### - (`::Vertx::FileProps`) lprops_blocking(path = nil)

Blocking version of #lprops

Parameters:

- path (`String`) (defaults to: `nil`)

Returns:

- (`::Vertx::FileProps`)

Raises:

- (`ArgumentError`)

    276
    277
    278
    279
    280
    281
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 276

    def lprops_blocking(path=nil)
      if path.class == String && !block_given?
        return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:lpropsBlocking, [Java::java.lang.String.java_class]).call(path),::Vertx::FileProps)
      end
      raise ArgumentError, "Invalid arguments when calling lprops_blocking(#{path})"
    end

### - (`self`) mkdir(path = nil, perms = nil) { ... }

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.

Parameters:

- path (`String`) (defaults to: `nil`) —
  path to the file
- perms (`String`) (defaults to: `nil`) —
  the permissions string

Yields:

- the handler that will be called on completion

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    428
    429
    430
    431
    432
    433
    434
    435
    436
    437
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 428

    def mkdir(path=nil,perms=nil)
      if path.class == String && block_given? && perms == nil
        @j_del.java_method(:mkdir, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(path,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      elsif path.class == String && perms.class == String && block_given?
        @j_del.java_method(:mkdir, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(path,perms,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling mkdir(#{path},#{perms})"
    end

### - (`self`) mkdir_blocking(path = nil, perms = nil)

Blocking version of #mkdir

Parameters:

- path (`String`) (defaults to: `nil`)
- perms (`String`) (defaults to: `nil`)

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    442
    443
    444
    445
    446
    447
    448
    449
    450
    451
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 442

    def mkdir_blocking(path=nil,perms=nil)
      if path.class == String && !block_given? && perms == nil
        @j_del.java_method(:mkdirBlocking, [Java::java.lang.String.java_class]).call(path)
        return self
      elsif path.class == String && perms.class == String && !block_given?
        @j_del.java_method(:mkdirBlocking, [Java::java.lang.String.java_class,Java::java.lang.String.java_class]).call(path,perms)
        return self
      end
      raise ArgumentError, "Invalid arguments when calling mkdir_blocking(#{path},#{perms})"
    end

### - (`self`) mkdirs(path = nil, perms = nil) { ... }

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.

Parameters:

- path (`String`) (defaults to: `nil`) —
  path to the file
- perms (`String`) (defaults to: `nil`) —
  the permissions string

Yields:

- the handler that will be called on completion

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    464
    465
    466
    467
    468
    469
    470
    471
    472
    473
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 464

    def mkdirs(path=nil,perms=nil)
      if path.class == String && block_given? && perms == nil
        @j_del.java_method(:mkdirs, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(path,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      elsif path.class == String && perms.class == String && block_given?
        @j_del.java_method(:mkdirs, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(path,perms,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling mkdirs(#{path},#{perms})"
    end

### - (`self`) mkdirs_blocking(path = nil, perms = nil)

Blocking version of #mkdirs

Parameters:

- path (`String`) (defaults to: `nil`)
- perms (`String`) (defaults to: `nil`)

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    478
    479
    480
    481
    482
    483
    484
    485
    486
    487
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 478

    def mkdirs_blocking(path=nil,perms=nil)
      if path.class == String && !block_given? && perms == nil
        @j_del.java_method(:mkdirsBlocking, [Java::java.lang.String.java_class]).call(path)
        return self
      elsif path.class == String && perms.class == String && !block_given?
        @j_del.java_method(:mkdirsBlocking, [Java::java.lang.String.java_class,Java::java.lang.String.java_class]).call(path,perms)
        return self
      end
      raise ArgumentError, "Invalid arguments when calling mkdirs_blocking(#{path},#{perms})"
    end

### - (`self`) move(from = nil, to = nil, options = nil) { ... }

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

Parameters:

- from (`String`) (defaults to: `nil`) —
  the path to copy from
- to (`String`) (defaults to: `nil`) —
  the path to copy to
- options (`Hash`) (defaults to: `nil`) —
  options describing how the file should be copied

Yields:

- the handler that will be called on completion

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 110

    def move(from=nil,to=nil,options=nil)
      if from.class == String && to.class == String && block_given? && options == nil
        @j_del.java_method(:move, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(from,to,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      elsif from.class == String && to.class == String && options.class == Hash && block_given?
        @j_del.java_method(:move, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCoreFile::CopyOptions.java_class,Java::IoVertxCore::Handler.java_class]).call(from,to,Java::IoVertxCoreFile::CopyOptions.new(::Vertx::Util::Utils.to_json_object(options)),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling move(#{from},#{to},#{options})"
    end

### - (`self`) move_blocking(from = nil, to = nil)

Blocking version of #move

Parameters:

- from (`String`) (defaults to: `nil`)
- to (`String`) (defaults to: `nil`)

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    124
    125
    126
    127
    128
    129
    130
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 124

    def move_blocking(from=nil,to=nil)
      if from.class == String && to.class == String && !block_given?
        @j_del.java_method(:moveBlocking, [Java::java.lang.String.java_class,Java::java.lang.String.java_class]).call(from,to)
        return self
      end
      raise ArgumentError, "Invalid arguments when calling move_blocking(#{from},#{to})"
    end

### - (`self`) open(path = nil, options = nil) { ... }

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.

Parameters:

- path (`String`) (defaults to: `nil`) —
  path to the file
- options (`Hash`) (defaults to: `nil`) —
  options describing how the file should be opened

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    573
    574
    575
    576
    577
    578
    579
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 573

    def open(path=nil,options=nil)
      if path.class == String && options.class == Hash && block_given?
        @j_del.java_method(:open, [Java::java.lang.String.java_class,Java::IoVertxCoreFile::OpenOptions.java_class,Java::IoVertxCore::Handler.java_class]).call(path,Java::IoVertxCoreFile::OpenOptions.new(::Vertx::Util::Utils.to_json_object(options)),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ::Vertx::Util::Utils.safe_create(ar.result,::Vertx::AsyncFile) : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling open(#{path},#{options})"
    end

### - (`::Vertx::AsyncFile`) open_blocking(path = nil, options = nil)

Blocking version of #open

Parameters:

- path (`String`) (defaults to: `nil`)
- options (`Hash`) (defaults to: `nil`)

Returns:

- (`::Vertx::AsyncFile`)

Raises:

- (`ArgumentError`)

    584
    585
    586
    587
    588
    589
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 584

    def open_blocking(path=nil,options=nil)
      if path.class == String && options.class == Hash && !block_given?
        return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:openBlocking, [Java::java.lang.String.java_class,Java::IoVertxCoreFile::OpenOptions.java_class]).call(path,Java::IoVertxCoreFile::OpenOptions.new(::Vertx::Util::Utils.to_json_object(options))),::Vertx::AsyncFile)
      end
      raise ArgumentError, "Invalid arguments when calling open_blocking(#{path},#{options})"
    end

### - (`self`) props(path = nil) { ... }

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

If the file is a link, the link will be followed.

Parameters:

- path (`String`) (defaults to: `nil`) —
  the path to the file

Yields:

- the handler that will be called on completion

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    244
    245
    246
    247
    248
    249
    250
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 244

    def props(path=nil)
      if path.class == String && block_given?
        @j_del.java_method(:props, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(path,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ::Vertx::Util::Utils.safe_create(ar.result,::Vertx::FileProps) : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling props(#{path})"
    end

### - (`::Vertx::FileProps`) props_blocking(path = nil)

Blocking version of #props

Parameters:

- path (`String`) (defaults to: `nil`)

Returns:

- (`::Vertx::FileProps`)

Raises:

- (`ArgumentError`)

    254
    255
    256
    257
    258
    259
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 254

    def props_blocking(path=nil)
      if path.class == String && !block_given?
        return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:propsBlocking, [Java::java.lang.String.java_class]).call(path),::Vertx::FileProps)
      end
      raise ArgumentError, "Invalid arguments when calling props_blocking(#{path})"
    end

### - (`self`) read_dir(path = nil, filter = nil) { ... }

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.

Parameters:

- path (`String`) (defaults to: `nil`) —
  path to the directory
- filter (`String`) (defaults to: `nil`) —
  the filter expression

Yields:

- the handler that will be called on completion

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    498
    499
    500
    501
    502
    503
    504
    505
    506
    507
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 498

    def read_dir(path=nil,filter=nil)
      if path.class == String && block_given? && filter == nil
        @j_del.java_method(:readDir, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(path,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result.to_a.map { |elt| elt } : nil) }))
        return self
      elsif path.class == String && filter.class == String && block_given?
        @j_del.java_method(:readDir, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(path,filter,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result.to_a.map { |elt| elt } : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling read_dir(#{path},#{filter})"
    end

### - (`Array<String>`) read_dir_blocking(path = nil, filter = nil)

Blocking version of #read_dir

Parameters:

- path (`String`) (defaults to: `nil`)
- filter (`String`) (defaults to: `nil`)

Returns:

- (`Array<String>`)

Raises:

- (`ArgumentError`)

    512
    513
    514
    515
    516
    517
    518
    519
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 512

    def read_dir_blocking(path=nil,filter=nil)
      if path.class == String && !block_given? && filter == nil
        return @j_del.java_method(:readDirBlocking, [Java::java.lang.String.java_class]).call(path).to_a.map { |elt| elt }
      elsif path.class == String && filter.class == String && !block_given?
        return @j_del.java_method(:readDirBlocking, [Java::java.lang.String.java_class,Java::java.lang.String.java_class]).call(path,filter).to_a.map { |elt| elt }
      end
      raise ArgumentError, "Invalid arguments when calling read_dir_blocking(#{path},#{filter})"
    end

### - (`self`) read_file(path = nil) { ... }

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.

Parameters:

- path (`String`) (defaults to: `nil`) —
  path to the file

Yields:

- the handler that will be called on completion

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    526
    527
    528
    529
    530
    531
    532
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 526

    def read_file(path=nil)
      if path.class == String && block_given?
        @j_del.java_method(:readFile, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(path,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ::Vertx::Util::Utils.safe_create(ar.result,::Vertx::Buffer) : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling read_file(#{path})"
    end

### - (`::Vertx::Buffer`) read_file_blocking(path = nil)

Blocking version of #read_file

Parameters:

- path (`String`) (defaults to: `nil`)

Returns:

- (`::Vertx::Buffer`)

Raises:

- (`ArgumentError`)

    536
    537
    538
    539
    540
    541
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 536

    def read_file_blocking(path=nil)
      if path.class == String && !block_given?
        return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:readFileBlocking, [Java::java.lang.String.java_class]).call(path),::Vertx::Buffer)
      end
      raise ArgumentError, "Invalid arguments when calling read_file_blocking(#{path})"
    end

### - (`self`) read_symlink(link = nil) { ... }

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

Parameters:

- link (`String`) (defaults to: `nil`) —
  the link

Yields:

- the handler that will be called on completion

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    353
    354
    355
    356
    357
    358
    359
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 353

    def read_symlink(link=nil)
      if link.class == String && block_given?
        @j_del.java_method(:readSymlink, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(link,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling read_symlink(#{link})"
    end

### - (`String`) read_symlink_blocking(link = nil)

Blocking version of #read_symlink

Parameters:

- link (`String`) (defaults to: `nil`)

Returns:

- (`String`)

Raises:

- (`ArgumentError`)

    363
    364
    365
    366
    367
    368
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 363

    def read_symlink_blocking(link=nil)
      if link.class == String && !block_given?
        return @j_del.java_method(:readSymlinkBlocking, [Java::java.lang.String.java_class]).call(link)
      end
      raise ArgumentError, "Invalid arguments when calling read_symlink_blocking(#{link})"
    end

### - (`self`) symlink(link = nil, existing = nil) { ... }

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

Parameters:

- link (`String`) (defaults to: `nil`) —
  the link
- existing (`String`) (defaults to: `nil`) —
  the link destination

Yields:

- the handler that will be called on completion

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    310
    311
    312
    313
    314
    315
    316
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 310

    def symlink(link=nil,existing=nil)
      if link.class == String && existing.class == String && block_given?
        @j_del.java_method(:symlink, [Java::java.lang.String.java_class,Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(link,existing,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling symlink(#{link},#{existing})"
    end

### - (`self`) symlink_blocking(link = nil, existing = nil)

Blocking version of #link

Parameters:

- link (`String`) (defaults to: `nil`)
- existing (`String`) (defaults to: `nil`)

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    321
    322
    323
    324
    325
    326
    327
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 321

    def symlink_blocking(link=nil,existing=nil)
      if link.class == String && existing.class == String && !block_given?
        @j_del.java_method(:symlinkBlocking, [Java::java.lang.String.java_class,Java::java.lang.String.java_class]).call(link,existing)
        return self
      end
      raise ArgumentError, "Invalid arguments when calling symlink_blocking(#{link},#{existing})"
    end

### - (`self`) truncate(path = nil, len = nil) { ... }

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

Parameters:

- path (`String`) (defaults to: `nil`) —
  the path to the file
- len (`Fixnum`) (defaults to: `nil`) —
  the length to truncate it to

Yields:

- the handler that will be called on completion

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    138
    139
    140
    141
    142
    143
    144
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 138

    def truncate(path=nil,len=nil)
      if path.class == String && len.class == Fixnum && block_given?
        @j_del.java_method(:truncate, [Java::java.lang.String.java_class,Java::long.java_class,Java::IoVertxCore::Handler.java_class]).call(path,len,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling truncate(#{path},#{len})"
    end

### - (`self`) truncate_blocking(path = nil, len = nil)

Blocking version of #truncate

Parameters:

- path (`String`) (defaults to: `nil`)
- len (`Fixnum`) (defaults to: `nil`)

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    149
    150
    151
    152
    153
    154
    155
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 149

    def truncate_blocking(path=nil,len=nil)
      if path.class == String && len.class == Fixnum && !block_given?
        @j_del.java_method(:truncateBlocking, [Java::java.lang.String.java_class,Java::long.java_class]).call(path,len)
        return self
      end
      raise ArgumentError, "Invalid arguments when calling truncate_blocking(#{path},#{len})"
    end

### - (`self`) unlink(link = nil) { ... }

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

Parameters:

- link (`String`) (defaults to: `nil`) —
  the link

Yields:

- the handler that will be called on completion

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    332
    333
    334
    335
    336
    337
    338
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 332

    def unlink(link=nil)
      if link.class == String && block_given?
        @j_del.java_method(:unlink, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(link,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling unlink(#{link})"
    end

### - (`self`) unlink_blocking(link = nil)

Blocking version of #unlink

Parameters:

- link (`String`) (defaults to: `nil`)

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    342
    343
    344
    345
    346
    347
    348
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 342

    def unlink_blocking(link=nil)
      if link.class == String && !block_given?
        @j_del.java_method(:unlinkBlocking, [Java::java.lang.String.java_class]).call(link)
        return self
      end
      raise ArgumentError, "Invalid arguments when calling unlink_blocking(#{link})"
    end

### - (`self`) write_file(path = nil, data = nil) { ... }

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

Parameters:

- path (`String`) (defaults to: `nil`) —
  path to the file
- data (`::Vertx::Buffer`) (defaults to: `nil`)

Yields:

- the handler that will be called on completion

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    548
    549
    550
    551
    552
    553
    554
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 548

    def write_file(path=nil,data=nil)
      if path.class == String && data.class.method_defined?(:j_del) && block_given?
        @j_del.java_method(:writeFile, [Java::java.lang.String.java_class,Java::IoVertxCoreBuffer::Buffer.java_class,Java::IoVertxCore::Handler.java_class]).call(path,data.j_del,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling write_file(#{path},#{data})"
    end

### - (`self`) write_file_blocking(path = nil, data = nil)

Blocking version of #write_file

Parameters:

- path (`String`) (defaults to: `nil`)
- data (`::Vertx::Buffer`) (defaults to: `nil`)

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    559
    560
    561
    562
    563
    564
    565
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/file_system.rb', line 559

    def write_file_blocking(path=nil,data=nil)
      if path.class == String && data.class.method_defined?(:j_del) && !block_given?
        @j_del.java_method(:writeFileBlocking, [Java::java.lang.String.java_class,Java::IoVertxCoreBuffer::Buffer.java_class]).call(path,data.j_del)
        return self
      end
      raise ArgumentError, "Invalid arguments when calling write_file_blocking(#{path},#{data})"
    end