Class AsyncFile
- java.lang.Object
-
- io.vertx.reactivex.core.file.AsyncFile
-
- All Implemented Interfaces:
io.vertx.lang.rx.RxDelegate,ReadStream<Buffer>,StreamBase,WriteStream<Buffer>
public class AsyncFile extends Object implements io.vertx.lang.rx.RxDelegate, ReadStream<Buffer>, WriteStream<Buffer>
Represents a file on the file-system which can be read from, or written to asynchronously.This class also implements
ReadStreamandWriteStream. This allows the data to be piped to and from other streams, e.g. anHttpClientRequestinstance, using thePipeclassNOTE: This class has been automatically generated from the
originalnon RX-ified interface using Vert.x codegen.
-
-
Field Summary
Fields Modifier and Type Field Description static io.vertx.lang.rx.TypeArg<AsyncFile>__TYPE_ARG
-
Method Summary
All Methods Static Methods Instance Methods Concrete Methods Modifier and Type Method Description Future<Void>close()Close the file.AsyncFiledrainHandler(Handler<Void> handler)Set a drain handler on the stream.Future<Void>end()Ends the stream.Future<Void>end(Buffer data)Same asWriteStream.end()but writes some data to the stream before ending.AsyncFileendHandler(Handler<Void> endHandler)Set an end handler.booleanequals(Object o)AsyncFileexceptionHandler(Handler<Throwable> handler)Set an exception handler on the read stream and on the write stream.AsyncFilefetch(long amount)Fetch the specifiedamountof elements.Future<Void>flush()Flush any writes made to this file to underlying persistent storage.AsyncFilegetDelegate()longgetReadLength()longgetWritePos()AsyncFilehandler(Handler<Buffer> handler)Set a data handler.inthashCode()Future<AsyncFileLock>lock()Acquire a non-shared lock on the entire file.Future<AsyncFileLock>lock(long position, long size, boolean shared)Acquire a lock on a portion of this file.static AsyncFilenewInstance(AsyncFile arg)AsyncFilepause()Pause theReadStream, it sets the buffer infetchmode and clears the actual demand.Pipe<Buffer>pipe()Pause this stream and return a to transfer the elements of this stream to a destination .Future<Void>pipeTo(WriteStream<Buffer> dst)Pipe thisReadStreamto theWriteStream.Future<Buffer>read(Buffer buffer, int offset, long position, int length)Readslengthbytes of data from the file at positionpositionin the file, asynchronously.AsyncFileresume()Resume reading, and sets the buffer inflowingmode.CompletablerxClose()Close the file.CompletablerxEnd()Ends the stream.CompletablerxEnd(Buffer data)Same asWriteStream.end()but writes some data to the stream before ending.CompletablerxFlush()Flush any writes made to this file to underlying persistent storage.Single<AsyncFileLock>rxLock()Acquire a non-shared lock on the entire file.Single<AsyncFileLock>rxLock(long position, long size, boolean shared)Acquire a lock on a portion of this file.CompletablerxPipeTo(WriteStream<Buffer> dst)Pipe thisReadStreamto theWriteStream.Single<Buffer>rxRead(Buffer buffer, int offset, long position, int length)Readslengthbytes of data from the file at positionpositionin the file, asynchronously.Single<Long>rxSize()<T> Single<T>rxWithLock(long position, long size, boolean shared, Supplier<Future<T>> block)Acquire a lock on a portion of this file.<T> Single<T>rxWithLock(Supplier<Future<T>> block)Acquire a non-shared lock on the entire file.CompletablerxWrite(Buffer data)Write some data to the stream.CompletablerxWrite(Buffer buffer, long position)Write aBufferto the file at positionpositionin the file, asynchronously.AsyncFilesetReadBufferSize(int readBufferSize)Sets the buffer size that will be used to read the data from the file.AsyncFilesetReadLength(long readLength)Sets the number of bytes that will be read when using the file as aReadStream.AsyncFilesetReadPos(long readPos)Sets the position from which data will be read from when using the file as aReadStream.AsyncFilesetWritePos(long writePos)Sets the position from which data will be written when using the file as aWriteStream.AsyncFilesetWriteQueueMaxSize(int maxSize)Set the maximum size of the write queue tomaxSize.Future<Long>size()longsizeBlocking()Likesize()but blocking.Flowable<Buffer>toFlowable()Observable<Buffer>toObservable()WriteStreamObserver<Buffer>toObserver()StringtoString()WriteStreamSubscriber<Buffer>toSubscriber()AsyncFileLocktryLock()Try to acquire a non-shared lock on the entire file.AsyncFileLocktryLock(long position, long size, boolean shared)Try to acquire a lock on a portion of this file.<T> Future<T>withLock(long position, long size, boolean shared, Supplier<Future<T>> block)Acquire a lock on a portion of this file.<T> Future<T>withLock(Supplier<Future<T>> block)Acquire a non-shared lock on the entire file.Future<Void>write(Buffer data)Write some data to the stream.Future<Void>write(Buffer buffer, long position)Write aBufferto the file at positionpositionin the file, asynchronously.booleanwriteQueueFull()This will returntrueif there are more bytes in the write queue than the value set usingsetWriteQueueMaxSize(int)
-
-
-
Field Detail
-
__TYPE_ARG
public static final io.vertx.lang.rx.TypeArg<AsyncFile> __TYPE_ARG
-
-
Method Detail
-
getDelegate
public AsyncFile getDelegate()
- Specified by:
getDelegatein interfaceReadStream<Buffer>- Specified by:
getDelegatein interfaceio.vertx.lang.rx.RxDelegate- Specified by:
getDelegatein interfaceStreamBase- Specified by:
getDelegatein interfaceWriteStream<Buffer>
-
toObservable
public Observable<Buffer> toObservable()
- Specified by:
toObservablein interfaceReadStream<Buffer>
-
toFlowable
public Flowable<Buffer> toFlowable()
- Specified by:
toFlowablein interfaceReadStream<Buffer>
-
toObserver
public WriteStreamObserver<Buffer> toObserver()
- Specified by:
toObserverin interfaceWriteStream<Buffer>
-
toSubscriber
public WriteStreamSubscriber<Buffer> toSubscriber()
- Specified by:
toSubscriberin interfaceWriteStream<Buffer>
-
pipe
public Pipe<Buffer> pipe()
Pause this stream and return a to transfer the elements of this stream to a destination . The stream will be resumed when the pipe will be wired to aWriteStream.- Specified by:
pipein interfaceReadStream<Buffer>- Returns:
- a pipe
-
pipeTo
public Future<Void> pipeTo(WriteStream<Buffer> dst)
Pipe thisReadStreamto theWriteStream.Elements emitted by this stream will be written to the write stream until this stream ends or fails.
- Specified by:
pipeToin interfaceReadStream<Buffer>- Parameters:
dst- the destination write stream- Returns:
- a future notified when the write stream will be ended with the outcome
-
rxPipeTo
public Completable rxPipeTo(WriteStream<Buffer> dst)
Pipe thisReadStreamto theWriteStream.Elements emitted by this stream will be written to the write stream until this stream ends or fails.
- Specified by:
rxPipeToin interfaceReadStream<Buffer>- Parameters:
dst- the destination write stream- Returns:
- a future notified when the write stream will be ended with the outcome
-
write
public Future<Void> write(Buffer data)
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
WriteStream.writeQueueFull()method before writing. This is done automatically if using a .When the
datais moved from the queue to the actual medium, the returned 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.- Specified by:
writein interfaceWriteStream<Buffer>- Parameters:
data- the data to write- Returns:
- a future completed with the write result
-
rxWrite
public Completable rxWrite(Buffer data)
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
WriteStream.writeQueueFull()method before writing. This is done automatically if using a .When the
datais moved from the queue to the actual medium, the returned 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.- Specified by:
rxWritein interfaceWriteStream<Buffer>- Parameters:
data- the data to write- Returns:
- a future completed with the write result
-
end
public Future<Void> end()
Ends the stream.Once the stream has ended, it cannot be used any more.
- Specified by:
endin interfaceWriteStream<Buffer>- Returns:
- a future completed with the result
-
rxEnd
public Completable rxEnd()
Ends the stream.Once the stream has ended, it cannot be used any more.
- Specified by:
rxEndin interfaceWriteStream<Buffer>- Returns:
- a future completed with the result
-
end
public Future<Void> end(Buffer data)
Same asWriteStream.end()but writes some data to the stream before ending.- Specified by:
endin interfaceWriteStream<Buffer>- Parameters:
data- the data to write- Returns:
- a future completed with the result
-
rxEnd
public Completable rxEnd(Buffer data)
Same asWriteStream.end()but writes some data to the stream before ending.- Specified by:
rxEndin interfaceWriteStream<Buffer>- Parameters:
data- the data to write- Returns:
- a future completed with the result
-
writeQueueFull
public boolean writeQueueFull()
This will returntrueif there are more bytes in the write queue than the value set usingsetWriteQueueMaxSize(int)- Specified by:
writeQueueFullin interfaceWriteStream<Buffer>- Returns:
trueif write queue is full
-
handler
public AsyncFile handler(Handler<Buffer> handler)
Description copied from interface:ReadStreamSet a data handler. As data is read, the handler will be called with the data.- Specified by:
handlerin interfaceReadStream<Buffer>- Returns:
- a reference to this, so the API can be used fluently
-
pause
public AsyncFile pause()
Description copied from interface:ReadStreamPause theReadStream, it sets the buffer infetchmode and clears the actual demand.While it's paused, no data will be sent to the data
handler.- Specified by:
pausein interfaceReadStream<Buffer>- Returns:
- a reference to this, so the API can be used fluently
-
resume
public AsyncFile resume()
Description copied from interface:ReadStreamResume reading, and sets the buffer inflowingmode. If theReadStreamhas been paused, reading will recommence on it.- Specified by:
resumein interfaceReadStream<Buffer>- Returns:
- a reference to this, so the API can be used fluently
-
endHandler
public AsyncFile endHandler(Handler<Void> endHandler)
Description copied from interface:ReadStreamSet an end handler. Once the stream has ended, and there is no more data to be read, this handler will be called.- Specified by:
endHandlerin interfaceReadStream<Buffer>- Returns:
- a reference to this, so the API can be used fluently
-
setWriteQueueMaxSize
public AsyncFile setWriteQueueMaxSize(int maxSize)
Description copied from interface:WriteStreamSet the maximum size of the write queue tomaxSize. You will still be able to write to the stream even if there is more thanmaxSizeitems in the write queue. This is used as an indicator by classes such asPipeto provide flow control. The value is defined by the implementation of the stream, e.g in bytes for aNetSocket, etc...- Specified by:
setWriteQueueMaxSizein interfaceWriteStream<Buffer>- Parameters:
maxSize- the max size of the write stream- Returns:
- a reference to this, so the API can be used fluently
-
drainHandler
public AsyncFile drainHandler(Handler<Void> handler)
Description copied from interface:WriteStreamSet a drain handler on the stream. If the write queue is full, then the handler will be called when the write queue is ready to accept buffers again. SeePipefor an example of this being used.The stream implementation defines when the drain handler, for example it could be when the queue size has been reduced to
maxSize / 2.- Specified by:
drainHandlerin interfaceWriteStream<Buffer>- Parameters:
handler- the handler- Returns:
- a reference to this, so the API can be used fluently
-
exceptionHandler
public AsyncFile exceptionHandler(Handler<Throwable> handler)
Set an exception handler on the read stream and on the write stream.- Specified by:
exceptionHandlerin interfaceReadStream<Buffer>- Specified by:
exceptionHandlerin interfaceStreamBase- Specified by:
exceptionHandlerin interfaceWriteStream<Buffer>- Parameters:
handler- the handler- Returns:
- a reference to this, so the API can be used fluently
-
fetch
public AsyncFile fetch(long amount)
Description copied from interface:ReadStreamFetch the specifiedamountof elements. If theReadStreamhas been paused, reading will recommence with the specifiedamountof items, otherwise the specifiedamountwill be added to the current stream demand.- Specified by:
fetchin interfaceReadStream<Buffer>- Returns:
- a reference to this, so the API can be used fluently
-
close
public Future<Void> close()
Close the file. The actual close happens asynchronously.- Returns:
- a future completed with the result
-
rxClose
public Completable rxClose()
Close the file. The actual close happens asynchronously.- Returns:
- a future completed with the result
-
write
public Future<Void> write(Buffer buffer, long position)
Write aBufferto the file at positionpositionin the file, asynchronously.If
positionlies 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
- Parameters:
buffer- the buffer to writeposition- the position in the file to write it at- Returns:
- a future notified when the write is complete
-
rxWrite
public Completable rxWrite(Buffer buffer, long position)
Write aBufferto the file at positionpositionin the file, asynchronously.If
positionlies 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
- Parameters:
buffer- the buffer to writeposition- the position in the file to write it at- Returns:
- a future notified when the write is complete
-
read
public Future<Buffer> read(Buffer buffer, int offset, long position, int length)
Readslengthbytes of data from the file at positionpositionin the file, asynchronously.The read data will be written into the specified
Buffer bufferat positionoffset.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.
- Parameters:
buffer- the buffer to read intooffset- the offset into the buffer where the data will be readposition- the position in the file where to start readinglength- the number of bytes to read- Returns:
- a future notified when the write is complete
-
rxRead
public Single<Buffer> rxRead(Buffer buffer, int offset, long position, int length)
Readslengthbytes of data from the file at positionpositionin the file, asynchronously.The read data will be written into the specified
Buffer bufferat positionoffset.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.
- Parameters:
buffer- the buffer to read intooffset- the offset into the buffer where the data will be readposition- the position in the file where to start readinglength- the number of bytes to read- Returns:
- a future notified when the write is complete
-
flush
public Future<Void> flush()
Flush any writes made to this file to underlying persistent storage.If the file was opened with
flushset totruethen calling this method will have no effect.The actual flush will happen asynchronously.
- Returns:
- a future completed with the result
-
rxFlush
public Completable rxFlush()
Flush any writes made to this file to underlying persistent storage.If the file was opened with
flushset totruethen calling this method will have no effect.The actual flush will happen asynchronously.
- Returns:
- a future completed with the result
-
setReadPos
public AsyncFile setReadPos(long readPos)
Sets the position from which data will be read from when using the file as aReadStream.- Parameters:
readPos- the position in the file- Returns:
- a reference to this, so the API can be used fluently
-
setReadLength
public AsyncFile setReadLength(long readLength)
Sets the number of bytes that will be read when using the file as aReadStream.- Parameters:
readLength- the bytes that will be read from the file- Returns:
- a reference to this, so the API can be used fluently
-
getReadLength
public long getReadLength()
- Returns:
- the number of bytes that will be read when using the file as a
ReadStream
-
setWritePos
public AsyncFile setWritePos(long writePos)
Sets the position from which data will be written when using the file as aWriteStream.- Parameters:
writePos- the position in the file- Returns:
- a reference to this, so the API can be used fluently
-
getWritePos
public long getWritePos()
- Returns:
- the current write position the file is at
-
setReadBufferSize
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- the buffer size- Returns:
- a reference to this, so the API can be used fluently
-
sizeBlocking
public long sizeBlocking()
Likesize()but blocking.- Returns:
-
tryLock
public AsyncFileLock tryLock()
Try to acquire a non-shared lock on the entire file.- Returns:
- the lock if it can be acquired immediately, otherwise
null
-
tryLock
public AsyncFileLock tryLock(long position, long size, boolean shared)
Try to acquire a lock on a portion of this file.- Parameters:
position- where the region startssize- the size of the regionshared- whether the lock should be shared- Returns:
- the lock if it can be acquired immediately, otherwise
null
-
lock
public Future<AsyncFileLock> lock()
Acquire a non-shared lock on the entire file.- Returns:
- a future indicating the completion of this operation
-
rxLock
public Single<AsyncFileLock> rxLock()
Acquire a non-shared lock on the entire file.- Returns:
- a future indicating the completion of this operation
-
lock
public Future<AsyncFileLock> lock(long position, long size, boolean shared)
Acquire a lock on a portion of this file.- Parameters:
position- where the region startssize- the size of the regionshared- whether the lock should be shared- Returns:
- a future indicating the completion of this operation
-
rxLock
public Single<AsyncFileLock> rxLock(long position, long size, boolean shared)
Acquire a lock on a portion of this file.- Parameters:
position- where the region startssize- the size of the regionshared- whether the lock should be shared- Returns:
- a future indicating the completion of this operation
-
withLock
public <T> Future<T> withLock(Supplier<Future<T>> block)
Acquire a non-shared lock on the entire file.When the
blockis called, the lock is already acquired, it will be released when theFuturereturned by the block completes.When the
blockfails, the lock is released and the returned future is failed with the cause of the failure.- Parameters:
block- the code block called after lock acquisition- Returns:
- the future returned by the
block
-
rxWithLock
public <T> Single<T> rxWithLock(Supplier<Future<T>> block)
Acquire a non-shared lock on the entire file.When the
blockis called, the lock is already acquired, it will be released when theFuturereturned by the block completes.When the
blockfails, the lock is released and the returned future is failed with the cause of the failure.- Parameters:
block- the code block called after lock acquisition- Returns:
- the future returned by the
block
-
withLock
public <T> Future<T> withLock(long position, long size, boolean shared, Supplier<Future<T>> block)
Acquire a lock on a portion of this file.When the
blockis called, the lock is already acquired , it will be released when theFuturereturned by the block completes.When the
blockfails, the lock is released and the returned future is failed with the cause of the failure.- Parameters:
position- where the region startssize- the size of the regionshared- whether the lock should be sharedblock- the code block called after lock acquisition- Returns:
- the future returned by the
block
-
rxWithLock
public <T> Single<T> rxWithLock(long position, long size, boolean shared, Supplier<Future<T>> block)
Acquire a lock on a portion of this file.When the
blockis called, the lock is already acquired , it will be released when theFuturereturned by the block completes.When the
blockfails, the lock is released and the returned future is failed with the cause of the failure.- Parameters:
position- where the region startssize- the size of the regionshared- whether the lock should be sharedblock- the code block called after lock acquisition- Returns:
- the future returned by the
block
-
-