Vert.x 4.5.13 · io.vertx.core.file.impl.AsyncFileImpl

Modifier and Type	Field and Description
private final AsynchronousFileChannel	ch
private boolean	closed
private Runnable	closedDeferred
private final ContextInternal	context
public static final int	DEFAULT_READ_BUFFER_SIZE
private Handler<Void>	drainHandler
private Handler<Void>	endHandler
private Handler<Throwable>	exceptionHandler
private Handler<Buffer>	handler
private static CompletionHandler<FileLock, PromiseInternal<AsyncFileLock>>	LOCK_COMPLETION
private static final Logger	log
private int	lwm
private int	maxWrites
private boolean	overflow
private InboundBuffer<Buffer>	queue
private int	readBufferSize
private long	readLength
private long	readPos
private final VertxInternal	vertx
private long	writePos
private long	writesOutstanding

Access	Constructor and Description
pack-priv	AsyncFileImpl(VertxInternal vertx, String path, OpenOptions options, ContextInternal context)

Method Summary

Modifier and Type	Method and Description
private void	check()
private void	checkClosed()
private void	checkContext()
public Future<Void>	close() Implements io.vertx.core.file.AsyncFile.close. Close the file.
public void	close(Handler<AsyncResult<Void>> the handler handler) Implements io.vertx.core.file.AsyncFile.close. Close the file.
private synchronized void	closeInternal(Handler<AsyncResult<Void>> handler)
private void	doClose(Handler<AsyncResult<Void>> handler)
private synchronized void	doFlush(Handler<AsyncResult<Void>> handler)
private void	doRead()
private synchronized void	doRead(ByteBuffer bb)
private void	doRead(Buffer writeBuff, int offset, ByteBuffer buff, long position, Promise<Buffer> promise) References Deprecated `Buffer` is deprecated or references (maybe indirectly) at least one deprecated element.
private synchronized void	doWrite(Buffer buffer, long position, Handler<AsyncResult<Void>> handler) References Deprecated `Buffer` is deprecated or references (maybe indirectly) at least one deprecated element.
private synchronized void	doWrite(ByteBuffer[] buffers, long position, Handler<AsyncResult<Void>> handler)
private void	doWrite(ByteBuffer buff, long position, long toWrite, Handler<AsyncResult<Void>> handler)
public synchronized AsyncFile	drainHandler(Handler<Void> handler) Implements io.vertx.core.file.AsyncFile.drainHandler.
public Future<Void>	end() Overrides default io.vertx.core.streams.WriteStream.end. Ends the stream.
public void	end(Handler<AsyncResult<Void>> handler) Overrides default io.vertx.core.streams.WriteStream.end. Implements io.vertx.core.streams.WriteStream.end. Same as `end()` but with an `handler` called when the operation completes
public synchronized AsyncFile	endHandler(Handler<Void> handler) Implements io.vertx.core.file.AsyncFile.endHandler.
public synchronized AsyncFile	exceptionHandler(Handler<Throwable> handler) Implements io.vertx.core.file.AsyncFile.exceptionHandler.
public AsyncFile	fetch(long amount) Implements io.vertx.core.file.AsyncFile.fetch. Fetch the specified `amount` of elements.
public Future<Void>	flush() Implements io.vertx.core.file.AsyncFile.flush. Flush any writes made to this file to underlying persistent storage.
public AsyncFile	flush(Handler<AsyncResult<Void>> handler) Implements io.vertx.core.file.AsyncFile.flush. Same as `flush` but the handler will be called when the flush is complete or if an error occurs
public synchronized long	getReadLength() Implements io.vertx.core.file.AsyncFile.getReadLength.
public synchronized long	getWritePos() Implements io.vertx.core.file.AsyncFile.getWritePos.
private void	handleBuffer(Buffer buff) References Deprecated `Buffer` is deprecated or references (maybe indirectly) at least one deprecated element.
private void	handleEnd()
private void	handleException(Throwable t)
public synchronized AsyncFile	handler(Handler<Buffer> handler) Implements io.vertx.core.file.AsyncFile.handler.
public Future<AsyncFileLock>	lock() Implements io.vertx.core.file.AsyncFile.lock. Acquire a non-shared lock on the entire file.
public void	lock(Handler<AsyncResult<AsyncFileLock>> handler) Implements io.vertx.core.file.AsyncFile.lock. Like `lock()` but the `handler` will be called when the operation is complete or if an error occurs.
public Future<AsyncFileLock>	lock(long where the region starts position, long the size of the region size, boolean whether the lock should be shared shared) Implements io.vertx.core.file.AsyncFile.lock. Acquire a lock on a portion of this file.
public void	lock(long position, long size, boolean shared, Handler<AsyncResult<AsyncFileLock>> handler) Implements io.vertx.core.file.AsyncFile.lock. Like `lock(long, long, boolean)` but the `handler` will be called when the operation is complete or if an error occurs.
public synchronized AsyncFile	pause() Implements io.vertx.core.file.AsyncFile.pause. Pause the `ReadStream`, it sets the buffer in `fetch` mode and clears the actual demand.
public synchronized AsyncFile	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) Implements io.vertx.core.file.AsyncFile.read. 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) Implements io.vertx.core.file.AsyncFile.read. 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 synchronized AsyncFile	resume() Implements io.vertx.core.file.AsyncFile.resume. Resume reading, and sets the buffer in `flowing` mode.
public synchronized AsyncFile	setReadBufferSize(int the buffer size readBufferSize) Implements io.vertx.core.file.AsyncFile.setReadBufferSize. Sets the buffer size that will be used to read the data from the file.
public synchronized AsyncFile	setReadLength(long the bytes that will be read from the file readLength) Implements io.vertx.core.file.AsyncFile.setReadLength. Sets the number of bytes that will be read when using the file as a `io.vertx.core.streams.ReadStream`.
public synchronized AsyncFile	setReadPos(long the position in the file readPos) Implements io.vertx.core.file.AsyncFile.setReadPos. Sets the position from which data will be read from when using the file as a `io.vertx.core.streams.ReadStream`.
public synchronized AsyncFile	setWritePos(long the position in the file writePos) Implements io.vertx.core.file.AsyncFile.setWritePos. Sets the position from which data will be written when using the file as a `io.vertx.core.streams.WriteStream`.
public synchronized AsyncFile	setWriteQueueMaxSize(int the max size of the write stream maxSize) Implements io.vertx.core.file.AsyncFile.setWriteQueueMaxSize. Set the maximum size of the write queue to `maxSize`.
public Future<Long>	size() Implements io.vertx.core.file.AsyncFile.size.
public long	sizeBlocking() Implements io.vertx.core.file.AsyncFile.sizeBlocking. Like `size()` but blocking.
public AsyncFileLock	tryLock() Implements io.vertx.core.file.AsyncFile.tryLock. Try to acquire a non-shared lock on the entire file.
public AsyncFileLock	tryLock(long where the region starts position, long the size of the region size, boolean whether the lock should be shared shared) Implements io.vertx.core.file.AsyncFile.tryLock. 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) Implements io.vertx.core.file.AsyncFile.write. 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) Implements io.vertx.core.file.AsyncFile.write. 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
public Future<Void>	write(Buffer the data to write buffer) Implements io.vertx.core.streams.WriteStream.write. References Deprecated `Buffer` is deprecated or references (maybe indirectly) at least one deprecated element. Write some data to the stream.
public synchronized void	write(Buffer buffer, Handler<AsyncResult<Void>> handler) Implements io.vertx.core.streams.WriteStream.write. References Deprecated `Buffer` is deprecated or references (maybe indirectly) at least one deprecated element. Same as `write(T)` but with an `handler` called when the operation completes
private void	writeInternal(ByteBuffer buff, long position, Handler<AsyncResult<Void>> handler)
public synchronized boolean	writeQueueFull() Implements io.vertx.core.streams.WriteStream.writeQueueFull. This will return `true` if there are more bytes in the write queue than the value set using `setWriteQueueMaxSize`

Inherited from java.lang.Object:: clone equals finalize getClass hashCode notify notifyAll toString wait wait wait

ch	back to summary
private final AsynchronousFileChannel ch

closed	back to summary
private boolean closed

closedDeferred	back to summary
private Runnable closedDeferred

context	back to summary
private final ContextInternal context

DEFAULT_READ_BUFFER_SIZE	back to summary
public static final int DEFAULT_READ_BUFFER_SIZE

drainHandler	back to summary
private Handler<Void> drainHandler

endHandler	back to summary
private Handler<Void> endHandler

exceptionHandler	back to summary
private Handler<Throwable> exceptionHandler

handler	back to summary
private Handler<Buffer> handler

LOCK_COMPLETION	back to summary
private static CompletionHandler<FileLock, PromiseInternal<AsyncFileLock>> LOCK_COMPLETION

log	back to summary
private static final Logger log

lwm	back to summary
private int lwm

maxWrites	back to summary
private int maxWrites

overflow	back to summary
private boolean overflow

queue	back to summary
private InboundBuffer<Buffer> queue

readBufferSize	back to summary
private int readBufferSize

readLength	back to summary
private long readLength

readPos	back to summary
private long readPos

vertx	back to summary
private final VertxInternal vertx

writePos	back to summary
private long writePos

writesOutstanding	back to summary
private long writesOutstanding

AsyncFileImpl	back to summary
pack-priv AsyncFileImpl(VertxInternal vertx, String path, OpenOptions options, ContextInternal context)

Method Detail

check	back to summary
private void check()

checkClosed	back to summary
private void checkClosed()

checkContext	back to summary
private void checkContext()

close	back to summary
public Future<Void> close() Implements io.vertx.core.file.AsyncFile.close. Doc from io.vertx.core.file.AsyncFile.close. Close the file. The actual close happens asynchronously. Returns:Future<Void> a future completed with the result Annotations @Override

back to summary

public Future<Void> close()

Implements io.vertx.core.file.AsyncFile.close.

Doc from io.vertx.core.file.AsyncFile.close.

Close the file. The actual close happens asynchronously.

Returns:Future<Void>

a future completed with the result

Annotations

@Override

close	back to summary
public void close(Handler<AsyncResult<Void>> handler) Implements io.vertx.core.file.AsyncFile.close. Doc from io.vertx.core.file.AsyncFile.close. 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 Annotations @Override

back to summary

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

Implements io.vertx.core.file.AsyncFile.close.

Doc from io.vertx.core.file.AsyncFile.close.

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

Annotations

@Override

closeInternal	back to summary
private synchronized void closeInternal(Handler<AsyncResult<Void>> handler)

doClose	back to summary
private void doClose(Handler<AsyncResult<Void>> handler)

doFlush	back to summary
private synchronized void doFlush(Handler<AsyncResult<Void>> handler)

doRead	back to summary
private void doRead()

doRead	back to summary
private synchronized void doRead(ByteBuffer bb)

doRead	back to summary
private void doRead(Buffer writeBuff, int offset, ByteBuffer buff, long position, Promise<Buffer> promise) References Deprecated `Buffer` is deprecated or references (maybe indirectly) at least one deprecated element. See corresponding docs for further information.

doWrite	back to summary
private synchronized void doWrite(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.

doWrite	back to summary
private synchronized void doWrite(ByteBuffer[] buffers, long position, Handler<AsyncResult<Void>> handler)

doWrite	back to summary
private void doWrite(ByteBuffer buff, long position, long toWrite, Handler<AsyncResult<Void>> handler)

drainHandler	back to summary
public synchronized AsyncFile drainHandler(Handler<Void> handler) Implements io.vertx.core.file.AsyncFile.drainHandler. Annotations @Override

drainHandler

back to summary

public synchronized AsyncFile drainHandler(Handler<Void> handler)

Implements io.vertx.core.file.AsyncFile.drainHandler.

Annotations

@Override

end	back to summary
public Future<Void> end() Overrides default io.vertx.core.streams.WriteStream.end. Doc from io.vertx.core.streams.WriteStream.end. Ends the stream. Once the stream has ended, it cannot be used any more. Returns:Future<Void> a future completed with the result Annotations @Override

end

back to summary

public Future<Void> end()

Overrides default io.vertx.core.streams.WriteStream.end.

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

Ends the stream.

Once the stream has ended, it cannot be used any more.

Returns:Future<Void>

a future completed with the result

Annotations

@Override

end back to summary

end	back to summary
public void end(Handler<AsyncResult<Void>> handler) Overrides default io.vertx.core.streams.WriteStream.end. Implements io.vertx.core.streams.WriteStream.end. Doc from io.vertx.core.streams.WriteStream.end. Same as `end()` but with an `handler` called when the operation completes Annotations @Override

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

Overrides default io.vertx.core.streams.WriteStream.end.

Implements io.vertx.core.streams.WriteStream.end.

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

Same as end() but with an handler called when the operation completes

Annotations

@Override

endHandler	back to summary
public synchronized AsyncFile endHandler(Handler<Void> handler) Implements io.vertx.core.file.AsyncFile.endHandler. Annotations @Override

endHandler

back to summary

public synchronized AsyncFile endHandler(Handler<Void> handler)

Implements io.vertx.core.file.AsyncFile.endHandler.

Annotations

@Override

exceptionHandler	back to summary
public synchronized AsyncFile exceptionHandler(Handler<Throwable> handler) Implements io.vertx.core.file.AsyncFile.exceptionHandler. Annotations @Override

exceptionHandler

back to summary

public synchronized AsyncFile exceptionHandler(Handler<Throwable> handler)

Implements io.vertx.core.file.AsyncFile.exceptionHandler.

Annotations

@Override

fetch back to summary

fetch	back to summary
public AsyncFile fetch(long amount) Implements io.vertx.core.file.AsyncFile.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)

Implements io.vertx.core.file.AsyncFile.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() Implements io.vertx.core.file.AsyncFile.flush. Doc from io.vertx.core.file.AsyncFile.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 Annotations @Override

public Future<Void> flush()

Implements io.vertx.core.file.AsyncFile.flush.

Doc from io.vertx.core.file.AsyncFile.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

Annotations

@Override

flush back to summary

flush	back to summary
public AsyncFile flush(Handler<AsyncResult<Void>> handler) Implements io.vertx.core.file.AsyncFile.flush. Doc from io.vertx.core.file.AsyncFile.flush. Same as `flush` but the handler will be called when the flush is complete or if an error occurs Annotations @Override

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

Implements io.vertx.core.file.AsyncFile.flush.

Doc from io.vertx.core.file.AsyncFile.flush.

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

Annotations

@Override

getReadLength back to summary

getReadLength	back to summary
public synchronized long getReadLength() Implements io.vertx.core.file.AsyncFile.getReadLength. Returns:long Doc from io.vertx.core.file.AsyncFile.getReadLength. the number of bytes that will be read when using the file as a `io.vertx.core.streams.ReadStream` Annotations @Override

public synchronized long getReadLength()

Implements io.vertx.core.file.AsyncFile.getReadLength.

Returns:long

Doc from io.vertx.core.file.AsyncFile.getReadLength.

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

Annotations

@Override

getWritePos	back to summary
public synchronized long getWritePos() Implements io.vertx.core.file.AsyncFile.getWritePos. Returns:long Doc from io.vertx.core.file.AsyncFile.getWritePos. the current write position the file is at Annotations @Override

getWritePos

back to summary

public synchronized long getWritePos()

Implements io.vertx.core.file.AsyncFile.getWritePos.

Returns:long

Doc from io.vertx.core.file.AsyncFile.getWritePos.

the current write position the file is at

Annotations

@Override

handleBuffer	back to summary
private void handleBuffer(Buffer buff) References Deprecated `Buffer` is deprecated or references (maybe indirectly) at least one deprecated element. See corresponding docs for further information.

handleEnd	back to summary
private void handleEnd()

handleException	back to summary
private void handleException(Throwable t)

handler

back to summary

public synchronized AsyncFile handler(Handler<Buffer> handler)

Implements io.vertx.core.file.AsyncFile.handler.

Annotations

@Override

lock

back to summary

public Future<AsyncFileLock> lock()

Implements io.vertx.core.file.AsyncFile.lock.

Doc from io.vertx.core.file.AsyncFile.lock.

Acquire a non-shared lock on the entire file.

Returns:Future<AsyncFileLock>

a future indicating the completion of this operation

Annotations

@Override

lock back to summary

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

Implements io.vertx.core.file.AsyncFile.lock.

Doc from io.vertx.core.file.AsyncFile.lock.

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

Annotations

@Override

lock

back to summary

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

Implements io.vertx.core.file.AsyncFile.lock.

Doc from io.vertx.core.file.AsyncFile.lock.

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

@Override

lock back to summary

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

Implements io.vertx.core.file.AsyncFile.lock.

Doc from io.vertx.core.file.AsyncFile.lock.

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

Annotations

@Override

pause back to summary

public synchronized AsyncFile pause()

Implements io.vertx.core.file.AsyncFile.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

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

Implements io.vertx.core.file.AsyncFile.read.

Doc from io.vertx.core.file.AsyncFile.read.

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

@Override

read back to summary

public Future<Buffer> read(Buffer buffer, int offset, long position, int length)

Implements io.vertx.core.file.AsyncFile.read.

Doc from io.vertx.core.file.AsyncFile.read.

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

Annotations

@Override

resume back to summary

public synchronized AsyncFile resume()

Implements io.vertx.core.file.AsyncFile.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 synchronized AsyncFile setReadBufferSize(int readBufferSize)

Implements io.vertx.core.file.AsyncFile.setReadBufferSize.

Doc from io.vertx.core.file.AsyncFile.setReadBufferSize.

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

@Override

setReadLength back to summary

public synchronized AsyncFile setReadLength(long readLength)

Implements io.vertx.core.file.AsyncFile.setReadLength.

Doc from io.vertx.core.file.AsyncFile.setReadLength.

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

@Override

setReadPos back to summary

public synchronized AsyncFile setReadPos(long readPos)

Implements io.vertx.core.file.AsyncFile.setReadPos.

Doc from io.vertx.core.file.AsyncFile.setReadPos.

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

@Override

setWritePos back to summary

public synchronized AsyncFile setWritePos(long writePos)

Implements io.vertx.core.file.AsyncFile.setWritePos.

Doc from io.vertx.core.file.AsyncFile.setWritePos.

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

@Override

setWriteQueueMaxSize back to summary

public synchronized AsyncFile setWriteQueueMaxSize(int maxSize)

Implements io.vertx.core.file.AsyncFile.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 Future<Long> size()

Implements io.vertx.core.file.AsyncFile.size.

Returns:Future<Long>

Doc from io.vertx.core.file.AsyncFile.size.

the size of the file

Annotations

@Override

sizeBlocking back to summary

public long sizeBlocking()

Implements io.vertx.core.file.AsyncFile.sizeBlocking.

Doc from io.vertx.core.file.AsyncFile.sizeBlocking.

Like size() but blocking.

Annotations

@Override

tryLock back to summary

public AsyncFileLock tryLock()

Implements io.vertx.core.file.AsyncFile.tryLock.

Doc from io.vertx.core.file.AsyncFile.tryLock.

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

Returns:AsyncFileLock

the lock if it can be acquired immediately, otherwise null

Annotations

@Override

tryLock back to summary

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

Implements io.vertx.core.file.AsyncFile.tryLock.

Doc from io.vertx.core.file.AsyncFile.tryLock.

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:AsyncFileLock

the lock if it can be acquired immediately, otherwise null

Annotations

@Override

write back to summary

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

Implements io.vertx.core.file.AsyncFile.write.

Doc from io.vertx.core.file.AsyncFile.write.

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

Annotations

@Override

write back to summary

public Future<Void> write(Buffer buffer, long position)

Implements io.vertx.core.file.AsyncFile.write.

Doc from io.vertx.core.file.AsyncFile.write.

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

Annotations

@Override

write back to summary

public Future<Void> write(Buffer buffer)

Implements io.vertx.core.streams.WriteStream.write.

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

References Deprecated

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

See corresponding docs for further information.

Write some data to the stream.

The data is usually put on an internal write queue, and the write actually happens asynchronously. To avoid running out of memory by putting too much on the write queue, check the writeQueueFull method before writing. This is done automatically if using a Pipe.

When the data is moved from the queue to the actual medium, the returned Future will be completed with the write result, e.g the future is succeeded when a server HTTP response buffer is written to the socket and failed if the remote client has closed the socket while the data was still pending for write.

Parameters

buffer:Buffer: the data to write

Returns:Future<Void>

a future completed with the write result

Annotations

@Override

write back to summary

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

Implements io.vertx.core.streams.WriteStream.write.

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

References Deprecated

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

See corresponding docs for further information.

Same as write(T) but with an handler called when the operation completes

Annotations

@Override

writeInternal	back to summary
private void writeInternal(ByteBuffer buff, long position, Handler<AsyncResult<Void>> handler)

writeQueueFull back to summary

public synchronized boolean writeQueueFull()

Implements io.vertx.core.streams.WriteStream.writeQueueFull.

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

This will return true if there are more bytes in the write queue than the value set using setWriteQueueMaxSize

Returns:boolean

true if write queue is full

Annotations

@Override

public Class AsyncFileImpl

Field Summary

Constructor Summary

Method Summary

Field Detail

Constructor Detail

Method Detail