Class AsyncFile
- java.lang.Object
-
- io.vertx.rxjava.core.file.AsyncFile
-
- All Implemented Interfaces:
ReadStream<Buffer>
,StreamBase
,WriteStream<Buffer>
public class AsyncFile extends Object implements ReadStream<Buffer>, WriteStream<Buffer>
Represents a file on the file-system which can be read from, or written to asynchronously.This class also implements
NOTE: This class has been automatically generated from theReadStream
andWriteStream
. This allows the data to be piped to and from other streams, e.g. anHttpClientRequest
instance, using thePipe
classoriginal
non RX-ified interface using Vert.x codegen.
-
-
Field Summary
Fields Modifier and Type Field Description static TypeArg<AsyncFile>
__TYPE_ARG
-
Method Summary
All Methods Static Methods Instance Methods Concrete Methods Modifier and Type Method Description void
close()
Close the file.void
close(Handler<AsyncResult<Void>> handler)
Close the file.AsyncFile
drainHandler(Handler<Void> handler)
Set a drain handler on the stream.void
end()
Same asWriteStream.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)
but with anhandler
called when the operation completesvoid
end(Handler<AsyncResult<Void>> handler)
Same asWriteStream.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)
but with anhandler
called when the operation completesvoid
end(Buffer data)
Same as but with anhandler
called when the operation completesvoid
end(Buffer data, Handler<AsyncResult<Void>> handler)
Same as but with anhandler
called when the operation completesAsyncFile
endHandler(Handler<Void> endHandler)
Set an end handler.boolean
equals(Object o)
AsyncFile
exceptionHandler(Handler<Throwable> handler)
Set an exception handler on the read stream.AsyncFile
fetch(long amount)
Fetch the specifiedamount
of elements.AsyncFile
flush()
Same asflush(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)
but the handler will be called when the flush is complete or if an error occursAsyncFile
flush(Handler<AsyncResult<Void>> handler)
Same asflush(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)
but the handler will be called when the flush is complete or if an error occursAsyncFile
getDelegate()
long
getReadLength()
long
getWritePos()
AsyncFile
handler(Handler<Buffer> handler)
Set a data handler.int
hashCode()
void
lock()
Likelock(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.file.AsyncFileLock>>)
but thehandler
will be called when the operation is complete or if an error occurs.void
lock(long position, long size, boolean shared)
Likelock(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.file.AsyncFileLock>>)
but thehandler
will be called when the operation is complete or if an error occurs.void
lock(long position, long size, boolean shared, Handler<AsyncResult<AsyncFileLock>> handler)
Likelock(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.file.AsyncFileLock>>)
but thehandler
will be called when the operation is complete or if an error occurs.void
lock(Handler<AsyncResult<AsyncFileLock>> handler)
Likelock(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.file.AsyncFileLock>>)
but thehandler
will be called when the operation is complete or if an error occurs.static AsyncFile
newInstance(AsyncFile arg)
AsyncFile
pause()
Pause theReadStream
, it sets the buffer infetch
mode and clears the actual demand.Pipe<Buffer>
pipe()
Pause this stream and return a to transfer the elements of this stream to a destination .void
pipeTo(WriteStream<Buffer> dst)
Pipe thisReadStream
to theWriteStream
.void
pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)
Pipe thisReadStream
to theWriteStream
.AsyncFile
read(Buffer buffer, int offset, long position, int length)
Readslength
bytes of data from the file at positionposition
in the file, asynchronously.AsyncFile
read(Buffer buffer, int offset, long position, int length, Handler<AsyncResult<Buffer>> handler)
Readslength
bytes of data from the file at positionposition
in the file, asynchronously.AsyncFile
resume()
Resume reading, and sets the buffer inflowing
mode.rx.Single<Void>
rxClose()
Close the file.rx.Single<Void>
rxEnd()
Same asWriteStream.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)
but with anhandler
called when the operation completesrx.Single<Void>
rxEnd(Buffer data)
Same as but with anhandler
called when the operation completesrx.Single<Void>
rxFlush()
Same asflush(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)
but the handler will be called when the flush is complete or if an error occursrx.Single<AsyncFileLock>
rxLock()
Likelock(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.file.AsyncFileLock>>)
but thehandler
will be called when the operation is complete or if an error occurs.rx.Single<AsyncFileLock>
rxLock(long position, long size, boolean shared)
Likelock(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.file.AsyncFileLock>>)
but thehandler
will be called when the operation is complete or if an error occurs.rx.Single<Void>
rxPipeTo(WriteStream<Buffer> dst)
Pipe thisReadStream
to theWriteStream
.rx.Single<Buffer>
rxRead(Buffer buffer, int offset, long position, int length)
Readslength
bytes of data from the file at positionposition
in the file, asynchronously.rx.Single<Long>
rxSize()
Likesize(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Long>>)
but thehandler
will be called when the operation is complete or if an error occurs.rx.Single<Void>
rxWrite(Buffer data)
Same as but with anhandler
called when the operation completesrx.Single<Void>
rxWrite(Buffer buffer, long position)
Write aBuffer
to the file at positionposition
in the file, asynchronously.AsyncFile
setReadBufferSize(int readBufferSize)
Sets the buffer size that will be used to read the data from the file.AsyncFile
setReadLength(long readLength)
Sets the number of bytes that will be read when using the file as aReadStream
.AsyncFile
setReadPos(long readPos)
Sets the position from which data will be read from when using the file as aReadStream
.AsyncFile
setWritePos(long writePos)
Sets the position from which data will be written when using the file as aWriteStream
.AsyncFile
setWriteQueueMaxSize(int maxSize)
Set the maximum size of the write queue tomaxSize
.void
size()
Likesize(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Long>>)
but thehandler
will be called when the operation is complete or if an error occurs.void
size(Handler<AsyncResult<Long>> handler)
Likesize(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Long>>)
but thehandler
will be called when the operation is complete or if an error occurs.long
sizeBlocking()
Likesize(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Long>>)
but blocking.rx.Observable<Buffer>
toObservable()
String
toString()
WriteStreamSubscriber<Buffer>
toSubscriber()
AsyncFileLock
tryLock()
Try to acquire a non-shared lock on the entire file.AsyncFileLock
tryLock(long position, long size, boolean shared)
Try to acquire a lock on a portion of this file.void
write(Buffer data)
Same as but with anhandler
called when the operation completesvoid
write(Buffer buffer, long position)
Write aBuffer
to the file at positionposition
in the file, asynchronously.void
write(Buffer buffer, long position, Handler<AsyncResult<Void>> handler)
Write aBuffer
to the file at positionposition
in the file, asynchronously.void
write(Buffer data, Handler<AsyncResult<Void>> handler)
Same as but with anhandler
called when the operation completesboolean
writeQueueFull()
This will returntrue
if there are more bytes in the write queue than the value set usingsetWriteQueueMaxSize(int)
-
-
-
Method Detail
-
getDelegate
public AsyncFile getDelegate()
- Specified by:
getDelegate
in interfaceReadStream<Buffer>
- Specified by:
getDelegate
in interfaceStreamBase
- Specified by:
getDelegate
in interfaceWriteStream<Buffer>
-
toObservable
public rx.Observable<Buffer> toObservable()
- Specified by:
toObservable
in interfaceReadStream<Buffer>
-
toSubscriber
public WriteStreamSubscriber<Buffer> toSubscriber()
-
write
public void write(Buffer data, Handler<AsyncResult<Void>> handler)
Same as but with anhandler
called when the operation completes- Specified by:
write
in interfaceWriteStream<Buffer>
- Parameters:
data
-handler
-
-
write
public void write(Buffer data)
Same as but with anhandler
called when the operation completes- Specified by:
write
in interfaceWriteStream<Buffer>
- Parameters:
data
-
-
rxWrite
public rx.Single<Void> rxWrite(Buffer data)
Same as but with anhandler
called when the operation completes- Specified by:
rxWrite
in interfaceWriteStream<Buffer>
- Parameters:
data
-- Returns:
-
end
public void end(Handler<AsyncResult<Void>> handler)
Same asWriteStream.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)
but with anhandler
called when the operation completes- Specified by:
end
in interfaceWriteStream<Buffer>
- Parameters:
handler
-
-
end
public void end()
Same asWriteStream.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)
but with anhandler
called when the operation completes- Specified by:
end
in interfaceWriteStream<Buffer>
-
rxEnd
public rx.Single<Void> rxEnd()
Same asWriteStream.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)
but with anhandler
called when the operation completes- Specified by:
rxEnd
in interfaceWriteStream<Buffer>
- Returns:
-
end
public void end(Buffer data, Handler<AsyncResult<Void>> handler)
Same as but with anhandler
called when the operation completes- Specified by:
end
in interfaceWriteStream<Buffer>
- Parameters:
data
-handler
-
-
end
public void end(Buffer data)
Same as but with anhandler
called when the operation completes- Specified by:
end
in interfaceWriteStream<Buffer>
- Parameters:
data
-
-
rxEnd
public rx.Single<Void> rxEnd(Buffer data)
Same as but with anhandler
called when the operation completes- Specified by:
rxEnd
in interfaceWriteStream<Buffer>
- Parameters:
data
-- Returns:
-
writeQueueFull
public boolean writeQueueFull()
This will returntrue
if there are more bytes in the write queue than the value set usingsetWriteQueueMaxSize(int)
- Specified by:
writeQueueFull
in interfaceWriteStream<Buffer>
- Returns:
true
if write queue is full
-
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:
pipe
in interfaceReadStream<Buffer>
- Returns:
- a pipe
-
pipeTo
public void pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)
Pipe thisReadStream
to theWriteStream
.Elements emitted by this stream will be written to the write stream until this stream ends or fails.
Once this stream has ended or failed, the write stream will be ended and the
handler
will be called with the result.- Specified by:
pipeTo
in interfaceReadStream<Buffer>
- Parameters:
dst
- the destination write streamhandler
-
-
pipeTo
public void pipeTo(WriteStream<Buffer> dst)
Pipe thisReadStream
to theWriteStream
.Elements emitted by this stream will be written to the write stream until this stream ends or fails.
Once this stream has ended or failed, the write stream will be ended and the
handler
will be called with the result.- Specified by:
pipeTo
in interfaceReadStream<Buffer>
- Parameters:
dst
- the destination write stream
-
rxPipeTo
public rx.Single<Void> rxPipeTo(WriteStream<Buffer> dst)
Pipe thisReadStream
to theWriteStream
.Elements emitted by this stream will be written to the write stream until this stream ends or fails.
Once this stream has ended or failed, the write stream will be ended and the
handler
will be called with the result.- Specified by:
rxPipeTo
in interfaceReadStream<Buffer>
- Parameters:
dst
- the destination write stream- Returns:
-
handler
public AsyncFile handler(Handler<Buffer> handler)
Description copied from interface:ReadStream
Set a data handler. As data is read, the handler will be called with the data.- Specified by:
handler
in interfaceReadStream<Buffer>
- Returns:
- a reference to this, so the API can be used fluently
-
pause
public AsyncFile pause()
Description copied from interface:ReadStream
Pause theReadStream
, it sets the buffer infetch
mode and clears the actual demand.While it's paused, no data will be sent to the data
handler
.- Specified by:
pause
in interfaceReadStream<Buffer>
- Returns:
- a reference to this, so the API can be used fluently
-
resume
public AsyncFile resume()
Description copied from interface:ReadStream
Resume reading, and sets the buffer inflowing
mode. If theReadStream
has been paused, reading will recommence on it.- Specified by:
resume
in 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:ReadStream
Set an end handler. Once the stream has ended, and there is no more data to be read, this handler will be called.- Specified by:
endHandler
in interfaceReadStream<Buffer>
- Returns:
- a reference to this, so the API can be used fluently
-
setWriteQueueMaxSize
public AsyncFile setWriteQueueMaxSize(int maxSize)
Description copied from interface:WriteStream
Set the maximum size of the write queue tomaxSize
. You will still be able to write to the stream even if there is more thanmaxSize
items in the write queue. This is used as an indicator by classes such asPipe
to provide flow control. The value is defined by the implementation of the stream, e.g in bytes for aNetSocket
, etc...- Specified by:
setWriteQueueMaxSize
in 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:WriteStream
Set 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. SeePipe
for 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:
drainHandler
in 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)
Description copied from interface:ReadStream
Set an exception handler on the read stream.- Specified by:
exceptionHandler
in interfaceReadStream<Buffer>
- Specified by:
exceptionHandler
in interfaceStreamBase
- Specified by:
exceptionHandler
in interfaceWriteStream<Buffer>
- Parameters:
handler
- the exception handler- Returns:
- a reference to this, so the API can be used fluently
-
fetch
public AsyncFile fetch(long amount)
Description copied from interface:ReadStream
Fetch the specifiedamount
of elements. If theReadStream
has been paused, reading will recommence with the specifiedamount
of items, otherwise the specifiedamount
will be added to the current stream demand.- Specified by:
fetch
in interfaceReadStream<Buffer>
- Returns:
- a reference to this, so the API can be used fluently
-
close
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
- the handler
-
close
public void close()
Close the file. The actual close happens asynchronously. The handler will be called when the close is complete, or an error occurs.
-
rxClose
public rx.Single<Void> rxClose()
Close the file. The actual close happens asynchronously. The handler will be called when the close is complete, or an error occurs.- Returns:
-
write
public void write(Buffer buffer, long position, Handler<AsyncResult<Void>> handler)
Write aBuffer
to the file at positionposition
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
- the buffer to writeposition
- the position in the file to write it athandler
- the handler to call when the write is complete
-
write
public void write(Buffer buffer, long position)
Write aBuffer
to the file at positionposition
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
- the buffer to writeposition
- the position in the file to write it at
-
rxWrite
public rx.Single<Void> rxWrite(Buffer buffer, long position)
Write aBuffer
to the file at positionposition
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
- the buffer to writeposition
- the position in the file to write it at- Returns:
-
read
public AsyncFile read(Buffer buffer, int offset, long position, int length, Handler<AsyncResult<Buffer>> handler)
Readslength
bytes of data from the file at positionposition
in the file, asynchronously.The read data will be written into the specified
Buffer buffer
at 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.
The handler will be called when the close is complete, or if an error occurs.
- 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 readhandler
- the handler to call when the write is complete- Returns:
- a reference to this, so the API can be used fluently
-
read
public AsyncFile read(Buffer buffer, int offset, long position, int length)
Readslength
bytes of data from the file at positionposition
in the file, asynchronously.The read data will be written into the specified
Buffer buffer
at 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.
The handler will be called when the close is complete, or if an error occurs.
- 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 reference to this, so the API can be used fluently
-
rxRead
public rx.Single<Buffer> rxRead(Buffer buffer, int offset, long position, int length)
Readslength
bytes of data from the file at positionposition
in the file, asynchronously.The read data will be written into the specified
Buffer buffer
at 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.
The handler will be called when the close is complete, or if an error occurs.
- 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 reference to this, so the API can be used fluently
-
flush
public AsyncFile flush(Handler<AsyncResult<Void>> handler)
Same asflush(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)
but the handler will be called when the flush is complete or if an error occurs- Parameters:
handler
-- Returns:
-
flush
public AsyncFile flush()
Same asflush(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)
but the handler will be called when the flush is complete or if an error occurs- Returns:
-
rxFlush
public rx.Single<Void> rxFlush()
Same asflush(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)
but the handler will be called when the flush is complete or if an error occurs- Returns:
-
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(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Long>>)
but blocking.- Returns:
-
size
public void size(Handler<AsyncResult<Long>> handler)
Likesize(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Long>>)
but thehandler
will be called when the operation is complete or if an error occurs.- Parameters:
handler
-
-
size
public void size()
Likesize(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Long>>)
but thehandler
will be called when the operation is complete or if an error occurs.
-
rxSize
public rx.Single<Long> rxSize()
Likesize(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Long>>)
but thehandler
will be called when the operation is complete or if an error occurs.- 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 void lock(Handler<AsyncResult<AsyncFileLock>> handler)
Likelock(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.file.AsyncFileLock>>)
but thehandler
will be called when the operation is complete or if an error occurs.- Parameters:
handler
-
-
lock
public void lock()
Likelock(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.file.AsyncFileLock>>)
but thehandler
will be called when the operation is complete or if an error occurs.
-
rxLock
public rx.Single<AsyncFileLock> rxLock()
Likelock(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.file.AsyncFileLock>>)
but thehandler
will be called when the operation is complete or if an error occurs.- Returns:
-
lock
public void lock(long position, long size, boolean shared, Handler<AsyncResult<AsyncFileLock>> handler)
Likelock(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.file.AsyncFileLock>>)
but thehandler
will be called when the operation is complete or if an error occurs.- Parameters:
position
-size
-shared
-handler
-
-
lock
public void lock(long position, long size, boolean shared)
Likelock(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.file.AsyncFileLock>>)
but thehandler
will be called when the operation is complete or if an error occurs.- Parameters:
position
-size
-shared
-
-
rxLock
public rx.Single<AsyncFileLock> rxLock(long position, long size, boolean shared)
Likelock(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.file.AsyncFileLock>>)
but thehandler
will be called when the operation is complete or if an error occurs.- Parameters:
position
-size
-shared
-- Returns:
-
-