Class List Method List File List

# Class: Vertx::FileSystem

Inherits:
  Object
  - Object
  - Vertx::FileSystem
  show all
Defined in:
  /Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/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.

## 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 #chown.
- - (self) copy(from = nil, to = 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) { ... }
  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.

## 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`)

    144
    145
    146
    147
    148
    149
    150
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/file_system.rb', line 144

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

    155
    156
    157
    158
    159
    160
    161
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/file_system.rb', line 155

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

    173
    174
    175
    176
    177
    178
    179
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/file_system.rb', line 173

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

    185
    186
    187
    188
    189
    190
    191
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/file_system.rb', line 185

    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
- group (`String`) (defaults to: `nil`) —
  the user group

Yields:

- the handler that will be called on completion

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    198
    199
    200
    201
    202
    203
    204
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/file_system.rb', line 198

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

Parameters:

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

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    211
    212
    213
    214
    215
    216
    217
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/file_system.rb', line 211

    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) { ... }

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

The copy will fail 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

Yields:

- the handler that will be called on completion

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    38
    39
    40
    41
    42
    43
    44
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/file_system.rb', line 38

    def copy(from=nil,to=nil)
      if from.class == String && to.class == String && block_given?
        @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
      end
      raise ArgumentError, "Invalid arguments when calling copy(from,to)"
    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`)

    49
    50
    51
    52
    53
    54
    55
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/file_system.rb', line 49

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

    67
    68
    69
    70
    71
    72
    73
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/file_system.rb', line 67

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

    79
    80
    81
    82
    83
    84
    85
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/file_system.rb', line 79

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

    575
    576
    577
    578
    579
    580
    581
    582
    583
    584
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/file_system.rb', line 575

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

    589
    590
    591
    592
    593
    594
    595
    596
    597
    598
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/file_system.rb', line 589

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

    353
    354
    355
    356
    357
    358
    359
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/file_system.rb', line 353

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

    363
    364
    365
    366
    367
    368
    369
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/file_system.rb', line 363

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

    378
    379
    380
    381
    382
    383
    384
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/file_system.rb', line 378

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

    389
    390
    391
    392
    393
    394
    395
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/file_system.rb', line 389

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

    603
    604
    605
    606
    607
    608
    609
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/file_system.rb', line 603

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

    613
    614
    615
    616
    617
    618
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/file_system.rb', line 613

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

    623
    624
    625
    626
    627
    628
    629
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/file_system.rb', line 623

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

    633
    634
    635
    636
    637
    638
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/file_system.rb', line 633

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

    267
    268
    269
    270
    271
    272
    273
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/file_system.rb', line 267

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

    278
    279
    280
    281
    282
    283
    284
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/file_system.rb', line 278

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

    246
    247
    248
    249
    250
    251
    252
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/file_system.rb', line 246

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

    256
    257
    258
    259
    260
    261
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/file_system.rb', line 256

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

    408
    409
    410
    411
    412
    413
    414
    415
    416
    417
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/file_system.rb', line 408

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

    422
    423
    424
    425
    426
    427
    428
    429
    430
    431
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/file_system.rb', line 422

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

    444
    445
    446
    447
    448
    449
    450
    451
    452
    453
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/file_system.rb', line 444

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

    458
    459
    460
    461
    462
    463
    464
    465
    466
    467
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/file_system.rb', line 458

    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) { ... }

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

The move will fail 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

Yields:

- the handler that will be called on completion

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    93
    94
    95
    96
    97
    98
    99
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/file_system.rb', line 93

    def move(from=nil,to=nil)
      if from.class == String && to.class == String && block_given?
        @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
      end
      raise ArgumentError, "Invalid arguments when calling move(from,to)"
    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`)

    104
    105
    106
    107
    108
    109
    110
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/file_system.rb', line 104

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

    553
    554
    555
    556
    557
    558
    559
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/file_system.rb', line 553

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

    564
    565
    566
    567
    568
    569
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/file_system.rb', line 564

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

    224
    225
    226
    227
    228
    229
    230
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/file_system.rb', line 224

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

    234
    235
    236
    237
    238
    239
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/file_system.rb', line 234

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

    478
    479
    480
    481
    482
    483
    484
    485
    486
    487
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/file_system.rb', line 478

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

    492
    493
    494
    495
    496
    497
    498
    499
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/file_system.rb', line 492

    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 user 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`)

    506
    507
    508
    509
    510
    511
    512
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/file_system.rb', line 506

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

    516
    517
    518
    519
    520
    521
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/file_system.rb', line 516

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

    333
    334
    335
    336
    337
    338
    339
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/file_system.rb', line 333

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

    343
    344
    345
    346
    347
    348
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/file_system.rb', line 343

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

    290
    291
    292
    293
    294
    295
    296
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/file_system.rb', line 290

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

    301
    302
    303
    304
    305
    306
    307
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/file_system.rb', line 301

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

    118
    119
    120
    121
    122
    123
    124
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/file_system.rb', line 118

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

    129
    130
    131
    132
    133
    134
    135
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/file_system.rb', line 129

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

    312
    313
    314
    315
    316
    317
    318
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/file_system.rb', line 312

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

    322
    323
    324
    325
    326
    327
    328
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/file_system.rb', line 322

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

    528
    529
    530
    531
    532
    533
    534
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/file_system.rb', line 528

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

    539
    540
    541
    542
    543
    544
    545
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/src/main/resources/vertx/file_system.rb', line 539

    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