Uses of Class
net.sf.asyncobjects.Promise

Packages that use Promise

net.sf.asyncobjects	The core classes of the framework.
net.sf.asyncobjects.io	This package contains core IO interfaces.
net.sf.asyncobjects.io.adapters	This package contains adapters to blocking java streams.
net.sf.asyncobjects.io.util	This package contains uitility input and output streams.
net.sf.asyncobjects.net	This package contains core network interfaces.
net.sf.asyncobjects.net.nio	This package contains implementation of network interfaces that is based on non-blocking NIO socket API.
net.sf.asyncobjects.net.threading	This package contains implementation of network interfaces that is based on blocking socket API.
net.sf.asyncobjects.util	This package contains generic utilities that helps to develop asynchronous operations.
net.sf.asyncobjects.util.callbacks	This package contains a generic callbacks interfaces and adapter classes that help to implement them.
net.sf.asyncobjects.util.timer	This package contains generic timer interfaces and implementation of them over Timer nad TimerTask classes.

Uses of Promise in net.sf.asyncobjects

Methods in net.sf.asyncobjects that return Promise

protected Promise<? extends R>	When.bodySmashed(Throwable problem) This method is called if the method When.resolved(Object) throws exception or when promise returned from that method is smashed.
<O> Promise<O>	Promise.cast(Class<O> type) Cast promise to another type.
Promise<Void>	ACloseable.close() Close resource
Promise<T>	AsyncAction.doInOtherVat(Vat vat) Execute action in context of other vat.
Promise<T>	AsyncAction.executeLater() Execute action in current vat.
Promise<T>	AsyncAction.executeNow() Execute action in current vat.
protected Promise<?>	When.finallyDo() This action is called when promise is already either resolved or smashed if this method returns promise, the result promise is not resolved until a promise returned by this method is resolved.
Promise<Void>	Promise.finished()
static Promise<Void>	Promise.finished(Promise<?> in)
static <O> Promise<O>	Promise.notNull(Promise<? extends O> p) Return promise that never returns null.
static <O> Promise<O>	Promise.notNull(Promise<? extends O> p, String text) Return promise that never returns null.
static <T> Promise<T>	Promise.nullPromise() Return a promise resolved to null.
protected Promise<? extends T>	Using.openFailed(Throwable problem) This method is called in separate turn in case when open operation failed.
Promise<T>	AsyncUnicastServer.promise()
Promise<T>	Using.promise()
Promise<R>	When.promise()
protected abstract Promise<? extends R>	When.resolved(I value) This method is called when promise is overloaded in subclasses.
abstract Promise<? extends T>	AsyncAction.run() This abstract method is basically "main" for vat.
protected abstract Promise<? extends T>	Using.run(S service) This method should be implemented by subclasses.
protected Promise<? extends R>	When.smashed(Throwable problem) This method is called when argument promise is broken.
static <T> Promise<T>	Promise.smashed(Throwable t) Create smashed promise
Promise<Void>	Promise.toVoid() Convert promise to promise for void
static Promise<Void>	Promise.toVoid(Promise<?> in) Convert promise to promise for void
static <A> Promise<A>	Promise.upcast(Promise<? extends A> p) Upcast the promise.
static <T> Promise<T>	Promise.with(T value) Get promise with value

Methods in net.sf.asyncobjects with parameters of type Promise

static Promise<Void>	Promise.finished(Promise<?> in)
static <O> Promise<O>	Promise.notNull(Promise<? extends O> p) Return promise that never returns null.
static <O> Promise<O>	Promise.notNull(Promise<? extends O> p, String text) Return promise that never returns null.
static Promise<Void>	Promise.toVoid(Promise<?> in) Convert promise to promise for void
static <A> Promise<A>	Promise.upcast(Promise<? extends A> p) Upcast the promise.

Constructors in net.sf.asyncobjects with parameters of type Promise

Using(Promise<S> servicePromise)
A constructor

When(Promise<? extends I> p)
A constructor from promise.

Uses of Promise in net.sf.asyncobjects.io

Methods in net.sf.asyncobjects.io that return Promise

protected Promise<Void>	EncoderTextOutput.beforeClose()
Promise<Void>	BufferedInput.close() close stream
Promise<Void>	BufferedOutput.close() register close request and possibly execute it.
Promise<Void>	Pipe.close() Channel close
Promise<Void>	Pipe.InternalPipeInput.close() close stream
Promise<Void>	Pipe.InternalPipeOutput.close() close stream
Promise<Void>	WrappingChannel.close()
static <D extends BatchedData<D>> Promise<Integer>	IOUtils.compare(AInput<D> in1, AInput<D> in2, int readSize) Compare inputs.
static <D extends BatchedData<D>> Promise<Long>	IOUtils.discard(AInput<D> in, long length, int readDataSize) Discard specified amount of elements from input.
Promise<Void>	AOutput.flush() Flush data in stream, upon return of this method all data will be written out to most underlying layer
Promise<Void>	BufferedOutput.flush()
Promise<Void>	EncoderTextOutput.flush()
Promise<Void>	Pipe.InternalPipeOutput.flush() Flush output
static <D extends BatchedData<D>> Promise<Long>	IOUtils.forward(AInput<D> in, AOutput<D> out, long length, int readDataSize) Forward data from input to output
static <D extends BatchedData<D>> Promise<Long>	IOUtils.forward(AInput<D> in, AOutput<D> out, long length, int readDataSize, boolean autoflush) Forward data from input to output
Promise<I>	AChannel.getInput()
Promise<I>	Pipe.getInput()
Promise<I>	WrappingChannel.getInput()
Promise<O>	AChannel.getOutput()
Promise<O>	Pipe.getOutput()
Promise<O>	WrappingChannel.getOutput()
Promise<Boolean>	AInput.isPushbackSupported()
Promise<Boolean>	BufferedInput.isPushbackSupported()
Promise<Boolean>	DecoderTextInput.isPushbackSupported()
Promise<Boolean>	Pipe.InternalPipeInput.isPushbackSupported()
Promise<D>	BatchedData.promise() Return a promise that wraps this value
Promise<BinaryData>	BinaryData.promise()
Promise<TextData>	TextData.promise()
Promise<Void>	AInput.pushback(D data) Attempt to return some data to stream.
Promise<Void>	BufferedInput.pushback(D pushbackData) Push data back to the stream
Promise<Void>	Pipe.pushback(D pushbackData) Push data back to the pipe
Promise<Void>	Pipe.InternalPipeInput.pushback(D pushbackData) Push data back to the stream
Promise<Void>	DecoderTextInput.pushback(TextData data) Push back the data
Promise<D>	AInput.read(int limit) Read some data.
Promise<D>	BufferedInput.read(int limit) read some bytes in buffer
Promise<TextData>	DecoderTextInput.read(int limit)
Promise<D>	Pipe.InternalPipeInput.read(int limit) read some bytes
static Promise<BinaryData>	IOUtils.readAll(AByteInput in, int limit) Read all data from the stream.
static Promise<TextData>	IOUtils.readAll(ATextInput in, int limit) Read all data from the stream.
static <D extends BatchedData<D>> Promise<D>	IOUtils.readAll(D initial, AInput<D> in, int limit) Read all data from the stream.
static Promise<BinaryData>	IOUtils.readFully(AByteInput in, int amount) Read exactly specified amount data from byte input
static Promise<TextData>	IOUtils.readFully(ATextInput in, int amount) Read exactly specified amount data from text input
static <D extends BatchedData<D>> Promise<D>	IOUtils.readFully(D empty, AInput<D> in, int amount) Read exactly specified amount data from byte input
static <D extends BatchedData<D>> Promise<Long>	IOUtils.repeat(AOutput<D> out, D data, long length) Write specified binary data repeating it until length bytes are written.
Promise<Void>	ByteStreamForwarder.start() Deprecated. start reading from one stream and writing to another.
Promise<Void>	AOutput.write(D data) This method writes out the data.
Promise<Void>	BufferedOutput.write(D data) write data
Promise<Void>	Pipe.InternalPipeOutput.write(D buffer) Write data to stream
Promise<Void>	EncoderTextOutput.write(TextData data) Encode data

Uses of Promise in net.sf.asyncobjects.io.adapters

Methods in net.sf.asyncobjects.io.adapters that return Promise

Promise<Void>	InputStreamAdapter.close() close stream
Promise<Void>	OutputStreamAdapter.close() close stream
Promise<Void>	OutputStreamAdapter.flush() Flush output
Promise<Boolean>	InputStreamAdapter.isPushbackSupported()
Promise<Void>	InputStreamAdapter.pushback(BinaryData data) Pushback data
Promise<BinaryData>	InputStreamAdapter.read(int limit) read some bytes
Promise<Void>	OutputStreamAdapter.write(BinaryData data) Write data to stream

Uses of Promise in net.sf.asyncobjects.io.util

Methods in net.sf.asyncobjects.io.util that return Promise

Promise<Void>	SavingInput.allWritten()
protected Promise<Void>	ExhaustingInput.beforeClose()
Promise<Void>	GeneratingInput.close()
Promise<Void>	MulticastOutput.close() Close stream
Promise<Void>	NulInput.close()
Promise<Void>	RecordingOutput.close()
Promise<D>	RecordingOutput.dataPromise()
Promise<Void>	ExhaustingInput.exhausted()
Promise<Void>	MulticastOutput.flush() Flush data
Promise<Void>	RecordingOutput.flush()
Promise<Long>	GeneratingInput.generated()
Promise<Boolean>	BoundedInput.isPushbackSupported()
Promise<Boolean>	ExhaustingInput.isPushbackSupported()
Promise<Boolean>	GeneratingInput.isPushbackSupported()
Promise<Boolean>	NulInput.isPushbackSupported()
Promise<Boolean>	SavingInput.isPushbackSupported()
Promise<Boolean>	UncloseableInput.isPushbackSupported()
Promise<Void>	BoundedInput.pushback(D data) Pushback data
Promise<Void>	ExhaustingInput.pushback(D data) Pushback
Promise<Void>	GeneratingInput.pushback(D data)
Promise<Void>	NulInput.pushback(D data)
Promise<Void>	SavingInput.pushback(D data) Pushbback some data
Promise<Void>	UncloseableInput.pushback(D data) Pushback
Promise<D>	BoundedInput.read(int limit) Read data
Promise<D>	ExhaustingInput.read(int limit) Read data
Promise<D>	GeneratingInput.read(int limit)
Promise<D>	NulInput.read(int limit)
Promise<D>	SavingInput.read(int limit) In addition to stantad semantics.
Promise<D>	UncloseableInput.read(int limit)
Promise<Void>	MulticastOutput.write(D data) Write data
Promise<Void>	RecordingOutput.write(D data)

Uses of Promise in net.sf.asyncobjects.net

Methods in net.sf.asyncobjects.net that return Promise

Promise<ASocket>	AServerSocket.accept() Accept incomming connection
Promise<Void>	AServerSocket.bind(int port) Bind to specified port
Promise<Void>	AServerSocket.bind(String host, int port, int backlog) Bind to specified port an host
Promise<Void>	ASocket.connect(String host, int port) Connect socket to specified port and host
Promise<Boolean>	ASocket.getTcpNoDelay() Get value of TCP_NODELAY option
Promise<AServerSocket>	ASocketFactory.makeServerSocket()
Promise<ASocket>	ASocketFactory.makeSocket()
Promise<Void>	ASocket.setTcpNoDelay(boolean optionValue) Set TCP_NODELAY option

Uses of Promise in net.sf.asyncobjects.net.nio

Methods in net.sf.asyncobjects.net.nio that return Promise

Promise<ASocket>	NIOServerSocket.accept() Accept connection
Promise<Void>	NIOServerSocket.bind(int port) Bind socket
Promise<Void>	NIOServerSocket.bind(String host, int port, int backlog) Bind socket
Promise<Void>	NIOServerSocket.close() Perform close operation
Promise<Void>	NIOSocket.close() close the socket
Promise<Void>	NIOStream.close() Close stream
Promise<Void>	NIOSocket.connect(String host, int port) A connecto operation
Promise<Void>	NIOSocketOutputStream.flush() Flush stream.
Promise<AByteInput>	NIOSocket.getInput()
Promise<AByteOutput>	NIOSocket.getOutput()
Promise<Boolean>	NIOSocket.getTcpNoDelay() Set TCP_NODELAY option
Promise<Boolean>	NIOSocketInputStream.isPushbackSupported()
Promise<AServerSocket>	NIOSocketFactory.makeServerSocket()
Promise<ASocket>	NIOSocketFactory.makeSocket()
Promise<Void>	NIOSocketInputStream.pushback(BinaryData data) Push back data
Promise<BinaryData>	NIOSocketInputStream.read(int limit) Read some bytes.
Promise<Void>	NIOSocket.setTcpNoDelay(boolean optionValue) Set TCP_NODELAY option
Promise<Void>	NIOSelectorVat.waitAcceptable(SelectionKey key) wait until socket will became acceptable
Promise<Void>	NIOSelectorVat.waitConnectable(SelectionKey key) wait until socket will became ready to finish connection
Promise<Void>	NIOSelectorVat.waitReadable(SelectionKey key) wait until socket will became readable
Promise<Void>	NIOSelectorVat.waitWritable(SelectionKey key) wait until socket will became writable
Promise<Void>	NIOSocketOutputStream.write(BinaryData data) Write data

Uses of Promise in net.sf.asyncobjects.net.threading

Methods in net.sf.asyncobjects.net.threading that return Promise

Promise<ASocket>	TServerSocket.accept() Accept connection for the socket
Promise<Void>	TServerSocket.bind(int port) Bind socket to specific port
Promise<Void>	TServerSocket.bind(String host, int port, int backlog) Bind socket to specific host and port
Promise<Void>	TServerSocket.close() Close socket
Promise<Void>	TSocket.close()
Promise<Void>	TSocket.TInputStreamAdapter.close()
Promise<Void>	TSocket.TOutputStreamAdapter.close()
Promise<Void>	TSocket.connect(String host, int port) Connect to specific host and port
Promise<AByteInput>	TSocket.getInput()
Promise<AByteOutput>	TSocket.getOutput()
Promise<Boolean>	TSocket.getTcpNoDelay() Get TCP_NODELAY
Promise<AServerSocket>	TSocketFactory.makeServerSocket()
Promise<ASocket>	TSocketFactory.makeSocket()
Promise<Void>	TSocket.setTcpNoDelay(boolean optionValue)

Uses of Promise in net.sf.asyncobjects.util

Methods in net.sf.asyncobjects.util that return Promise

Promise<Void>	ASemaphore.acquire()
Promise<Void>	Semaphore.acquire()
Promise<Void>	ASemaphore.acquire(int number) Aquiree a number of permits
Promise<Void>	Semaphore.acquire(int number)
static Promise<Object[]>	Wait.all(Promise<?>... promises) This method allows waiting until operations represented by promises will finish.
static Promise<Boolean>	Condition.and(Promise<Boolean>... args) This operations finishes with true only if all promises resolve to true.
static Promise<Object>	Wait.any(boolean ignoreFailures, Collection<?> values) A utilty variant of Wait.any(boolean, Iterator) method that gets a Collection as argument.
static Promise<Object>	Wait.any(boolean ignoreFailures, Iterator<Object> values) Calculate first ready value of failure from the iterator.
static Promise<Object>	Wait.any(boolean ignoreFailures, Object[] values) A utilty variant of Wait.any(boolean, Iterator) method that gets an array as argument.
Promise<Integer>	ASemaphore.availablePermits() This is amount of permits that are released but have not yet been acquired with a ASemaphore.acquire(int) call.
Promise<Integer>	Semaphore.availablePermits()
Promise<Void>	RequestQueue.awaken() Sleep until explicitly resumed.
protected Promise<Void>	CloseableWrapper.beforeClose() Handle close operation
Promise<Void>	CloseableWrapper.close()
Promise<Void>	CloseableWrapper.closed()
Promise<Integer>	ASemaphore.drainPermits() Drain all available permits.
Promise<Integer>	Semaphore.drainPermits()
static Promise<Boolean>	Condition.falsePromise()
protected Promise<?>	All.finallyDo() This callback is executed after all action finished and before result is returned.
protected Promise<?>	Any.finallyDo() This callback is executed after first action is finshed and before result is returned returned.
protected Promise<?>	Seq.finallyDo() This method is executed when all actions are finished.
Promise<T>	AQueue.get() Get object from the queue
Promise<T>	Queue.get()
static Promise<Boolean>	Condition.not(Promise<Boolean> v) Logical not operation.
static Promise<Boolean>	Condition.or(Promise<Boolean>... args) This operations finishes with false only if all promises resolve to false.
Promise<Integer>	ASemaphore.permitsBalance()
Promise<Integer>	Semaphore.permitsBalance()
Promise<Object[]>	All.promise()
Promise<Object>	Any.promise()
Promise<R>	AsyncProcess.promise()
Promise<R>	Seq.promise()
Promise<T>	Serialized.promise() Return a promise for action execution.
Promise<Void>	AQueue.put(T o) Put object from the queue
Promise<Void>	Queue.put(T o)
protected abstract Promise<? extends T>	Serialized.run() Action that should be queue on request queue
protected Promise<R>	Seq.smashed(int action, Throwable problem) Handle fault on one of actions.
protected Promise<Void>	AsyncProcess.ProcessWhen.smashed(Throwable problem) This imlementation just fails process using AsyncProcess.failure(Throwable) method.
protected Promise<? extends R>	CloseableWrapper.InvalidatingWhen.smashed(Throwable problem) In addition to base class functionaity, the stream is marked as invalid.
Promise<Void>	RequestQueue.startRequest() start performing request, usually this method is called after noPending or ready.
static Promise<Boolean>	Condition.truePromise()
static Promise<Boolean>	Condition.valueOf(boolean value) Return promise that represents a boolean value
static <T> Promise<Boolean>	Condition.was(T expected, Promise<?> actual) Check if value matches expected using Object.equals(Object).

Methods in net.sf.asyncobjects.util with parameters of type Promise

static Promise<Object[]>	Wait.all(Promise<?>... promises) This method allows waiting until operations represented by promises will finish.
static Promise<Boolean>	Condition.and(Promise<Boolean>... args) This operations finishes with true only if all promises resolve to true.
static void	LogUtils.logDebugOutcome(Logger log, String operation, Promise<?> operationPromise) Log outcome of promised operation
static void	LogUtils.logInfoOutcome(Logger log, String operation, Promise<?> operationPromise) Log outcome of promised operation
static void	LogUtils.logOutcome(Logger log, Level level, String operation, Promise<?> operationPromise) Log outcome of promised operation
static Promise<Boolean>	Condition.not(Promise<Boolean> v) Logical not operation.
static Promise<Boolean>	Condition.or(Promise<Boolean>... args) This operations finishes with false only if all promises resolve to false.
protected void	AsyncProcess.success(Promise<R> value) Subclasses should call this method to indicate that process finished successfully.
static <T> Promise<Boolean>	Condition.was(T expected, Promise<?> actual) Check if value matches expected using Object.equals(Object).

Constructors in net.sf.asyncobjects.util with parameters of type Promise

AsyncProcess.ProcessWhen(Promise<I> p)
A constructor

CloseableWrapper.InvalidatingWhen(Promise<I> p)
A constructor from superclass

Uses of Promise in net.sf.asyncobjects.util.callbacks

Methods in net.sf.asyncobjects.util.callbacks that return Promise

Promise<T>	ACallable.call()
protected abstract Promise<? extends T>	CallableAdapter.call() Call the action
Promise<T>	CallableAdapter.InternalCallableAdapter.call()
Promise<O>	AMapper.map(I value) Map a value
protected abstract Promise<? extends O>	MapperAdapter.map(I value) A map function
Promise<O>	MapperAdapter.InternalMapperAdapter.map(I value)

Uses of Promise in net.sf.asyncobjects.util.timer

Methods in net.sf.asyncobjects.util.timer that return Promise

Promise<Boolean>	TimerTaskAdapter.cancel() Cancel task.
Promise<Void>	TimerWrapper.close()
static <T> Promise<T>	TimerUtils.delayFor(ATimer timer, long delay, Promise<T> value) Delay returning value until spefied time
static <T> Promise<T>	TimerUtils.delayFor(ATimer timer, long delay, T value) Delay returning value until spefied time
static <T> Promise<T>	TimerUtils.delayUntil(ATimer timer, Date time, Promise<T> value) Delay returning value until spefied time
static <T> Promise<T>	TimerUtils.delayUntil(ATimer timer, Date time, T value) Delay returning value until spefied time
Promise<Integer>	ATimer.purge() Remove all tasks from the timer
Promise<Integer>	TimerWrapper.purge()
Promise<ACallable<Boolean>>	ATimer.schedule(Date time, ATimerTask task) Schedule task at specified time
Promise<ACallable<Boolean>>	TimerWrapper.schedule(Date time, ATimerTask task)
Promise<ACallable<Boolean>>	ATimer.schedule(Date firstTime, long period, ATimerTask task) Schedule task after specfied time with specified period
Promise<ACallable<Boolean>>	TimerWrapper.schedule(Date firstTime, long period, ATimerTask task)
Promise<ACallable<Boolean>>	ATimer.schedule(long delay, ATimerTask task) Schedule task after specified delay
Promise<ACallable<Boolean>>	TimerWrapper.schedule(long delay, ATimerTask task)
Promise<ACallable<Boolean>>	ATimer.schedule(long delay, long period, ATimerTask task) Schedule task after specfied delay with specified period
Promise<ACallable<Boolean>>	TimerWrapper.schedule(long delay, long period, ATimerTask task)
Promise<ACallable<Boolean>>	ATimer.scheduleAtFixedRate(Date firstTime, long period, ATimerTask task) Schedule task after specfied time with fixed rage
Promise<ACallable<Boolean>>	TimerWrapper.scheduleAtFixedRate(Date firstTime, long period, ATimerTask task)
Promise<ACallable<Boolean>>	ATimer.scheduleAtFixedRate(long delay, long period, ATimerTask task) Schedule task after specfied delay with fixed rate
Promise<ACallable<Boolean>>	TimerWrapper.scheduleAtFixedRate(long delay, long period, ATimerTask task)
static Promise<Void>	TimerUtils.sleepFor(ATimer timer, long ms) Sleep the specified amount of milliseconds
static Promise<Void>	TimerUtils.sleepUntil(ATimer timer, Date time) Sleep the specified amount of milliseconds
static <T> Promise<T>	TimerUtils.timeout(ATimer timer, long delay, Throwable t) Smash result promise with the specified exception after specified time
static <T> Promise<T>	TimerUtils.timeoutAt(ATimer timer, Date time, Throwable t) Smash result promise with the specified exception after specified time

Methods in net.sf.asyncobjects.util.timer with parameters of type Promise

static <T> Promise<T>	TimerUtils.delayFor(ATimer timer, long delay, Promise<T> value) Delay returning value until spefied time
static <T> Promise<T>	TimerUtils.delayUntil(ATimer timer, Date time, Promise<T> value) Delay returning value until spefied time