Vert.x 4.5.13 · io.vertx.core.file.AsyncFile · APIdia, the JavaDoc alternative

Method Summary

Modifier and Type	Method and Description
public Future<Void>	Returns: a future completed with the result close() Close the file.
public void	close(Handler<AsyncResult<Void>> the handler handler) Close the file.
public AsyncFile	drainHandler(Handler<Void> handler)
public AsyncFile	endHandler(Handler<Void> endHandler)
public AsyncFile	exceptionHandler(Handler<Throwable> handler)
public AsyncFile	fetch(long amount) Redeclares io.vertx.core.streams.ReadStream.fetch. Fetch the specified `amount` of elements.
public Future<Void>	Returns: a future completed with the result flush() Flush any writes made to this file to underlying persistent storage.
public AsyncFile	flush(Handler<AsyncResult<Void>> handler) Same as `flush` but the handler will be called when the flush is complete or if an error occurs
public long	Returns: the number of bytes that will be read when using the file as a `io.vertx.core.streams.ReadStream` getReadLength()
public long	Returns: the current write position the file is at getWritePos()
public AsyncFile	handler(Handler<Buffer> handler)
public Future<AsyncFileLock>	Returns: a future indicating the completion of this operation lock() Acquire a non-shared lock on the entire file.
public void	lock(Handler<AsyncResult<AsyncFileLock>> handler) Like `lock()` but the `handler` will be called when the operation is complete or if an error occurs.
public Future<AsyncFileLock>	Returns: a future indicating the completion of this operation lock(long where the region starts position, long the size of the region size, boolean whether the lock should be shared shared) Acquire a lock on a portion of this file.
public void	lock(long position, long size, boolean shared, Handler<AsyncResult<AsyncFileLock>> handler) Like `lock(long, long, boolean)` but the `handler` will be called when the operation is complete or if an error occurs.
public AsyncFile	pause() Redeclares io.vertx.core.streams.ReadStream.pause. Pause the `ReadStream`, it sets the buffer in `fetch` mode and clears the actual demand.
public AsyncFile	Returns: a reference to this, so the API can be used fluently read(Buffer the buffer to read into buffer, int the offset into the buffer where the data will be read offset, long the position in the file where to start reading position, int the number of bytes to read length, Handler<AsyncResult<Buffer>> the handler to call when the write is complete handler) References Deprecated `Buffer` is deprecated or references (maybe indirectly) at least one deprecated element. Reads `length` bytes of data from the file at position `position` in the file, asynchronously.
public Future<Buffer>	read(Buffer buffer, int offset, long position, int length) References Deprecated `Buffer` is deprecated or references (maybe indirectly) at least one deprecated element. Like `read(Buffer, int, long, int, Handler)` but returns a `Future` of the asynchronous result
public AsyncFile	resume() Redeclares io.vertx.core.streams.ReadStream.resume. Resume reading, and sets the buffer in `flowing` mode.
public AsyncFile	Returns: a reference to this, so the API can be used fluently setReadBufferSize(int the buffer size readBufferSize) Sets the buffer size that will be used to read the data from the file.
public AsyncFile	Returns: a reference to this, so the API can be used fluently setReadLength(long the bytes that will be read from the file readLength) Sets the number of bytes that will be read when using the file as a `io.vertx.core.streams.ReadStream`.
public AsyncFile	Returns: a reference to this, so the API can be used fluently setReadPos(long the position in the file readPos) Sets the position from which data will be read from when using the file as a `io.vertx.core.streams.ReadStream`.
public AsyncFile	Returns: a reference to this, so the API can be used fluently setWritePos(long the position in the file writePos) Sets the position from which data will be written when using the file as a `io.vertx.core.streams.WriteStream`.
public AsyncFile	setWriteQueueMaxSize(int the max size of the write stream maxSize) Redeclares io.vertx.core.streams.WriteStream.setWriteQueueMaxSize. Set the maximum size of the write queue to `maxSize`.
public default void	size(Handler<AsyncResult<Long>> handler) Like `size()` but the `handler` will be called when the operation is complete or if an error occurs.
public Future<Long>	Returns: the size of the file size()
public long	sizeBlocking() Like `size()` but blocking.
public @Nullable AsyncFileLock	Returns: the lock if it can be acquired immediately, otherwise `null` tryLock() Try to acquire a non-shared lock on the entire file.
public @Nullable AsyncFileLock	Returns: the lock if it can be acquired immediately, otherwise `null` tryLock(long where the region starts position, long the size of the region size, boolean whether the lock should be shared shared) Try to acquire a lock on a portion of this file.
public void	write(Buffer the buffer to write buffer, long the position in the file to write it at position, Handler<AsyncResult<Void>> the handler to call when the write is complete handler) References Deprecated `Buffer` is deprecated or references (maybe indirectly) at least one deprecated element. Write a `io.vertx.core.buffer.Buffer` to the file at position `position` in the file, asynchronously.
public Future<Void>	write(Buffer buffer, long position) References Deprecated `Buffer` is deprecated or references (maybe indirectly) at least one deprecated element. Like `write(Buffer, long, Handler)` but returns a `Future` of the asynchronous result

Inherited from io.vertx.core.streams.ReadStream:: collect endHandler exceptionHandler handler pipe pipeTo pipeTo
Inherited from io.vertx.core.streams.WriteStream:: drainHandler end end end end exceptionHandler write write writeQueueFull

Method Detail

close	back to summary
public Future<Void> close() Close the file. The actual close happens asynchronously. Returns:Future<Void> a future completed with the result

back to summary

public Future<Void> close()

Close the file. The actual close happens asynchronously.

Returns:Future<Void>: a future completed with the result

close	back to summary
public void close(Handler<AsyncResult<Void>> handler) Close the file. The actual close happens asynchronously. The handler will be called when the close is complete, or an error occurs. Parameters handler:Handler<AsyncResult<Void>> the handler

back to summary

public void close(Handler<AsyncResult<Void>> handler)

Close the file. The actual close happens asynchronously. The handler will be called when the close is complete, or an error occurs.

Parameters

handler:Handler<AsyncResult<Void>>: the handler

drainHandler	back to summary
public AsyncFile drainHandler(Handler<Void> handler) Annotations @Override

endHandler	back to summary
public AsyncFile endHandler(Handler<Void> endHandler) Annotations @Override

exceptionHandler	back to summary
public AsyncFile exceptionHandler(Handler<Throwable> handler) Annotations @Override

fetch back to summary

fetch	back to summary
public AsyncFile fetch(long amount) Redeclares io.vertx.core.streams.ReadStream.fetch. Doc from io.vertx.core.streams.ReadStream.fetch. Fetch the specified `amount` of elements. If the `ReadStream` has been paused, reading will recommence with the specified `amount` of items, otherwise the specified `amount` will be added to the current stream demand. Returns:AsyncFile a reference to this, so the API can be used fluently Annotations @Override

public AsyncFile fetch(long amount)

Redeclares io.vertx.core.streams.ReadStream.fetch.

Doc from io.vertx.core.streams.ReadStream.fetch.

Fetch the specified amount of elements. If the ReadStream has been paused, reading will recommence with the specified amount of items, otherwise the specified amount will be added to the current stream demand.

Returns:AsyncFile

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

Annotations

@Override

flush back to summary

flush	back to summary
public Future<Void> flush() Flush any writes made to this file to underlying persistent storage. If the file was opened with `flush` set to `true` then calling this method will have no effect. The actual flush will happen asynchronously. Returns:Future<Void> a future completed with the result

public Future<Void> flush()

Flush any writes made to this file to underlying persistent storage.

If the file was opened with flush set to true then calling this method will have no effect.

The actual flush will happen asynchronously.

Returns:Future<Void>: a future completed with the result

flush back to summary

flush	back to summary
public AsyncFile flush(Handler<AsyncResult<Void>> handler) Same as `flush` but the handler will be called when the flush is complete or if an error occurs Annotations @Fluent

public AsyncFile flush(Handler<AsyncResult<Void>> handler)

Same as flush but the handler will be called when the flush is complete or if an error occurs

Annotations

@Fluent

getReadLength	back to summary
public long getReadLength() Returns:long the number of bytes that will be read when using the file as a `io.vertx.core.streams.ReadStream`

getWritePos	back to summary
public long getWritePos() Returns:long the current write position the file is at

handler	back to summary
public AsyncFile handler(Handler<Buffer> handler) Annotations @Override

lock	back to summary
public Future<AsyncFileLock> lock() Acquire a non-shared lock on the entire file. Returns:Future<AsyncFileLock> a future indicating the completion of this operation Annotations @Unstable

lock

back to summary

public Future<AsyncFileLock> lock()

Acquire a non-shared lock on the entire file.

Returns:Future<AsyncFileLock>

a future indicating the completion of this operation

Annotations

@Unstable

lock back to summary

lock	back to summary
public void lock(Handler<AsyncResult<AsyncFileLock>> handler) Like `lock()` but the `handler` will be called when the operation is complete or if an error occurs. Annotations @Unstable

public void lock(Handler<AsyncResult<AsyncFileLock>> handler)

Like lock() but the handler will be called when the operation is complete or if an error occurs.

Annotations

@Unstable

lock	back to summary
public Future<AsyncFileLock> lock(long position, long size, boolean shared) Acquire a lock on a portion of this file. Parameters position:long where the region starts size:long the size of the region shared:boolean whether the lock should be shared Returns:Future<AsyncFileLock> a future indicating the completion of this operation Annotations @Unstable

lock

back to summary

public Future<AsyncFileLock> lock(long position, long size, boolean shared)

Acquire a lock on a portion of this file.

Parameters

position:long: where the region starts
size:long: the size of the region
shared:boolean: whether the lock should be shared

Returns:Future<AsyncFileLock>

a future indicating the completion of this operation

Annotations

@Unstable

lock back to summary

lock	back to summary
public void lock(long position, long size, boolean shared, Handler<AsyncResult<AsyncFileLock>> handler) Like `lock(long, long, boolean)` but the `handler` will be called when the operation is complete or if an error occurs. Annotations @Unstable

public void lock(long position, long size, boolean shared, Handler<AsyncResult<AsyncFileLock>> handler)

Like lock(long, long, boolean) but the handler will be called when the operation is complete or if an error occurs.

Annotations

@Unstable

pause back to summary

pause	back to summary
public AsyncFile pause() Redeclares io.vertx.core.streams.ReadStream.pause. Doc from io.vertx.core.streams.ReadStream.pause. Pause the `ReadStream`, it sets the buffer in `fetch` mode and clears the actual demand. While it's paused, no data will be sent to the data `handler`. Returns:AsyncFile a reference to this, so the API can be used fluently Annotations @Override

public AsyncFile pause()

Redeclares io.vertx.core.streams.ReadStream.pause.

Doc from io.vertx.core.streams.ReadStream.pause.

Pause the ReadStream, it sets the buffer in fetch mode and clears the actual demand.

While it's paused, no data will be sent to the data handler.

Returns:AsyncFile

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

Annotations

@Override

read back to summary

read	back to summary
public AsyncFile read(Buffer buffer, int offset, long position, int length, Handler<AsyncResult<Buffer>> handler) References Deprecated `Buffer` is deprecated or references (maybe indirectly) at least one deprecated element. See corresponding docs for further information. Reads `length` bytes of data from the file at position `position` in the file, asynchronously. The read data will be written into the specified `Buffer buffer` at position `offset`. If data is read past the end of the file then zero bytes will be read. When multiple reads are invoked on the same file there are no guarantees as to order in which those reads actually occur. The handler will be called when the close is complete, or if an error occurs. Parameters buffer:Buffer the buffer to read into offset:int the offset into the buffer where the data will be read position:long the position in the file where to start reading length:int the number of bytes to read handler:Handler<AsyncResult<Buffer>> the handler to call when the write is complete Returns:AsyncFile a reference to this, so the API can be used fluently Annotations @Fluent

public AsyncFile read(Buffer buffer, int offset, long position, int length, Handler<AsyncResult<Buffer>> handler)

References Deprecated

Buffer is deprecated or references (maybe indirectly) at least one deprecated element.

See corresponding docs for further information.

Reads length bytes of data from the file at position position in the file, asynchronously.

The read data will be written into the specified Buffer buffer at position offset.

If data is read past the end of the file then zero bytes will be read.

When multiple reads are invoked on the same file there are no guarantees as to order in which those reads actually occur.

The handler will be called when the close is complete, or if an error occurs.

Parameters

buffer:Buffer: the buffer to read into
offset:int: the offset into the buffer where the data will be read
position:long: the position in the file where to start reading
length:int: the number of bytes to read
handler:Handler<AsyncResult<Buffer>>: the handler to call when the write is complete

Returns:AsyncFile

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

Annotations

@Fluent

read	back to summary
public Future<Buffer> read(Buffer buffer, int offset, long position, int length) References Deprecated `Buffer` is deprecated or references (maybe indirectly) at least one deprecated element. See corresponding docs for further information. Like `read(Buffer, int, long, int, Handler)` but returns a `Future` of the asynchronous result

resume back to summary

resume	back to summary
public AsyncFile resume() Redeclares io.vertx.core.streams.ReadStream.resume. Doc from io.vertx.core.streams.ReadStream.resume. Resume reading, and sets the buffer in `flowing` mode. If the `ReadStream` has been paused, reading will recommence on it. Returns:AsyncFile a reference to this, so the API can be used fluently Annotations @Override

public AsyncFile resume()

Redeclares io.vertx.core.streams.ReadStream.resume.

Doc from io.vertx.core.streams.ReadStream.resume.

Resume reading, and sets the buffer in flowing mode.

If the ReadStream has been paused, reading will recommence on it.

Returns:AsyncFile

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

Annotations

@Override

setReadBufferSize	back to summary
public AsyncFile setReadBufferSize(int readBufferSize) Sets the buffer size that will be used to read the data from the file. Changing this value will impact how much the data will be read at a time from the file system. Parameters readBufferSize:int the buffer size Returns:AsyncFile a reference to this, so the API can be used fluently Annotations @Fluent

setReadBufferSize

back to summary

public AsyncFile setReadBufferSize(int readBufferSize)

Sets the buffer size that will be used to read the data from the file. Changing this value will impact how much the data will be read at a time from the file system.

Parameters

readBufferSize:int: the buffer size

Returns:AsyncFile

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

Annotations

@Fluent

setReadLength back to summary

setReadLength	back to summary
public AsyncFile setReadLength(long readLength) Sets the number of bytes that will be read when using the file as a `io.vertx.core.streams.ReadStream`. Parameters readLength:long the bytes that will be read from the file Returns:AsyncFile a reference to this, so the API can be used fluently Annotations @Fluent

public AsyncFile setReadLength(long readLength)

Sets the number of bytes that will be read when using the file as a io.vertx.core.streams.ReadStream.

Parameters

readLength:long: the bytes that will be read from the file

Returns:AsyncFile

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

Annotations

@Fluent

setReadPos back to summary

setReadPos	back to summary
public AsyncFile setReadPos(long readPos) Sets the position from which data will be read from when using the file as a `io.vertx.core.streams.ReadStream`. Parameters readPos:long the position in the file Returns:AsyncFile a reference to this, so the API can be used fluently Annotations @Fluent

public AsyncFile setReadPos(long readPos)

Sets the position from which data will be read from when using the file as a io.vertx.core.streams.ReadStream.

Parameters

readPos:long: the position in the file

Returns:AsyncFile

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

Annotations

@Fluent

setWritePos back to summary

setWritePos	back to summary
public AsyncFile setWritePos(long writePos) Sets the position from which data will be written when using the file as a `io.vertx.core.streams.WriteStream`. Parameters writePos:long the position in the file Returns:AsyncFile a reference to this, so the API can be used fluently Annotations @Fluent

public AsyncFile setWritePos(long writePos)

Sets the position from which data will be written when using the file as a io.vertx.core.streams.WriteStream.

Parameters

writePos:long: the position in the file

Returns:AsyncFile

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

Annotations

@Fluent

setWriteQueueMaxSize back to summary

setWriteQueueMaxSize	back to summary
public AsyncFile setWriteQueueMaxSize(int maxSize) Redeclares io.vertx.core.streams.WriteStream.setWriteQueueMaxSize. Doc from io.vertx.core.streams.WriteStream.setWriteQueueMaxSize. Set the maximum size of the write queue to `maxSize`. You will still be able to write to the stream even if there is more than `maxSize` items in the write queue. This is used as an indicator by classes such as `Pipe` to provide flow control. The value is defined by the implementation of the stream, e.g in bytes for a `io.vertx.core.net.NetSocket`, etc... Parameters maxSize:int the max size of the write stream Returns:AsyncFile a reference to this, so the API can be used fluently Annotations @Override

public AsyncFile setWriteQueueMaxSize(int maxSize)

Redeclares io.vertx.core.streams.WriteStream.setWriteQueueMaxSize.

Doc from io.vertx.core.streams.WriteStream.setWriteQueueMaxSize.

Set the maximum size of the write queue to maxSize. You will still be able to write to the stream even if there is more than maxSize items in the write queue. This is used as an indicator by classes such as Pipe to provide flow control.

The value is defined by the implementation of the stream, e.g in bytes for a io.vertx.core.net.NetSocket, etc...

Parameters

maxSize:int: the max size of the write stream

Returns:AsyncFile

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

Annotations

@Override

size	back to summary
public default void size(Handler<AsyncResult<Long>> handler) Like `size()` but the `handler` will be called when the operation is complete or if an error occurs.

size	back to summary
public Future<Long> size() Returns:Future<Long> the size of the file

sizeBlocking back to summary

sizeBlocking	back to summary
public long sizeBlocking() Like `size()` but blocking. Exceptions FileSystemException: if an error occurs

public long sizeBlocking()

Like size() but blocking.

Exceptions

FileSystemException:: if an error occurs

tryLock back to summary

tryLock	back to summary
public @Nullable AsyncFileLock tryLock() Try to acquire a non-shared lock on the entire file. Returns:@Nullable AsyncFileLock the lock if it can be acquired immediately, otherwise `null` Annotations @Unstable

public @Nullable AsyncFileLock tryLock()

Try to acquire a non-shared lock on the entire file.

Returns:@Nullable AsyncFileLock

the lock if it can be acquired immediately, otherwise null

Annotations

@Unstable

tryLock back to summary

tryLock	back to summary
public @Nullable AsyncFileLock tryLock(long position, long size, boolean shared) Try to acquire a lock on a portion of this file. Parameters position:long where the region starts size:long the size of the region shared:boolean whether the lock should be shared Returns:@Nullable AsyncFileLock the lock if it can be acquired immediately, otherwise `null` Annotations @Unstable

public @Nullable AsyncFileLock tryLock(long position, long size, boolean shared)

Try to acquire a lock on a portion of this file.

Parameters

position:long: where the region starts
size:long: the size of the region
shared:boolean: whether the lock should be shared

Returns:@Nullable AsyncFileLock

the lock if it can be acquired immediately, otherwise null

Annotations

@Unstable

write back to summary

write	back to summary
public void write(Buffer buffer, long position, Handler<AsyncResult<Void>> handler) References Deprecated `Buffer` is deprecated or references (maybe indirectly) at least one deprecated element. See corresponding docs for further information. Write a `io.vertx.core.buffer.Buffer` to the file at position `position` in the file, asynchronously. If `position` lies outside of the current size of the file, the file will be enlarged to encompass it. When multiple writes are invoked on the same file there are no guarantees as to order in which those writes actually occur The handler will be called when the write is complete, or if an error occurs. Parameters buffer:Buffer the buffer to write position:long the position in the file to write it at handler:Handler<AsyncResult<Void>> the handler to call when the write is complete

public void write(Buffer buffer, long position, Handler<AsyncResult<Void>> handler)

References Deprecated

Buffer is deprecated or references (maybe indirectly) at least one deprecated element.

See corresponding docs for further information.

Write a io.vertx.core.buffer.Buffer to the file at position position in the file, asynchronously.

If position lies outside of the current size of the file, the file will be enlarged to encompass it.

When multiple writes are invoked on the same file there are no guarantees as to order in which those writes actually occur

The handler will be called when the write is complete, or if an error occurs.

Parameters

buffer:Buffer: the buffer to write
position:long: the position in the file to write it at
handler:Handler<AsyncResult<Void>>: the handler to call when the write is complete

write	back to summary
public Future<Void> write(Buffer buffer, long position) References Deprecated `Buffer` is deprecated or references (maybe indirectly) at least one deprecated element. See corresponding docs for further information. Like `write(Buffer, long, Handler)` but returns a `Future` of the asynchronous result

public Interface AsyncFile

Method Summary

Method Detail