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
 



Copyright 2002-2007 Constantine Plotnikov. All Rights Reserved.