org.flexiblepower.context

Interface FlexiblePowerContext

public interface FlexiblePowerContext

The FlexiblePowerContext is a service for runtime system utilities. It can determine the current time (using the currentTime() and currentTimeMillis() methods) and it can run jobs (using the submit and schedule methods). The runtime should provide exactly one implementation of the FlexiblePowerContext that is used by the other components.

Method Summary

Methods

Modifier and Type	Method and Description
java.util.Date	currentTime()
long	currentTimeMillis() Returns the current time in milliseconds.
<V> java.util.concurrent.ScheduledFuture<V>	schedule(java.util.concurrent.Callable<V> callable, Measurable<Duration> delay) Creates and executes a ScheduledFuture that becomes enabled after the given delay.
java.util.concurrent.ScheduledFuture<?>	schedule(java.lang.Runnable command, Measurable<Duration> delay) Creates and executes a one-shot action that becomes enabled after the given delay.
java.util.concurrent.ScheduledFuture<?>	scheduleAtFixedRate(java.lang.Runnable command, Measurable<Duration> initialDelay, Measurable<Duration> period) Creates and executes a periodic action that becomes enabled first after the given initial delay, and subsequently with the given period; that is executions will commence after initialDelay then initialDelay+period, then initialDelay + 2 * period, and so on.
java.util.concurrent.ScheduledFuture<?>	scheduleWithFixedDelay(java.lang.Runnable command, Measurable<Duration> initialDelay, Measurable<Duration> delay) Creates and executes a periodic action that becomes enabled first after the given initial delay, and subsequently with the given delay between the termination of one execution and the commencement of the next.
<T> java.util.concurrent.Future<T>	submit(java.util.concurrent.Callable<T> task) Submits a value-returning task for execution and returns a Future representing the pending results of the task.
java.util.concurrent.Future<?>	submit(java.lang.Runnable task) Submits a Runnable task for execution and returns a Future representing that task.
<T> java.util.concurrent.Future<T>	submit(java.lang.Runnable task, T result) Submits a Runnable task for execution and returns a Future representing that task.

Method Detail

currentTimeMillis

long currentTimeMillis()

Returns the current time in milliseconds. Note that while the unit of time of the return value is a millisecond, the granularity of the value depends on the underlying operating system and may be larger. For example, many operating systems measure time in units of tens of milliseconds. See the description of the class Date for a discussion of slight discrepancies that may arise between "computer time" and coordinated universal time (UTC).

Returns:

the difference, measured in milliseconds, between the current time and midnight, January 1, 1970 UTC.

currentTime

java.util.Date currentTime()

Returns:

A new Date object that represents the current time. When calling the Date.getTime() method, this should always be the same as calling currentTimeMillis() directly.

submit

<T> java.util.concurrent.Future<T> submit(java.util.concurrent.Callable<T> task)

Submits a value-returning task for execution and returns a Future representing the pending results of the task. The Future's get method will return the task's result upon successful completion.

If you would like to immediately block waiting for a task, you can use constructions of the form result = exec.submit(aCallable).get();

Note: The Executors class includes a set of methods that can convert some other common closure-like objects, for example, PrivilegedAction to Callable form so they can be submitted.

Type Parameters:

T - the type of the task's result

Parameters:

task - the task to submit

Returns:

a Future representing pending completion of the task

Throws:

java.util.concurrent.RejectedExecutionException - if the task cannot be scheduled for execution

java.lang.NullPointerException - if the task is null

submit

<T> java.util.concurrent.Future<T> submit(java.lang.Runnable task,
                                        T result)

Submits a Runnable task for execution and returns a Future representing that task. The Future's get method will return the given result upon successful completion.

Type Parameters:

T - the type of the result

Parameters:

task - the task to submit

result - the result to return

Returns:

a Future representing pending completion of the task

Throws:

java.util.concurrent.RejectedExecutionException - if the task cannot be scheduled for execution

java.lang.NullPointerException - if the task is null

submit

java.util.concurrent.Future<?> submit(java.lang.Runnable task)

Submits a Runnable task for execution and returns a Future representing that task. The Future's get method will return null upon successful completion.

Parameters:

task - the task to submit

Returns:

a Future representing pending completion of the task

Throws:

java.util.concurrent.RejectedExecutionException - if the task cannot be scheduled for execution

java.lang.NullPointerException - if the task is null

schedule

java.util.concurrent.ScheduledFuture<?> schedule(java.lang.Runnable command,
                                               Measurable<Duration> delay)

Creates and executes a one-shot action that becomes enabled after the given delay.

Parameters:

command - the task to execute

delay - the time from now to delay execution

Returns:

a ScheduledFuture representing pending completion of the task and whose get() method will return null upon completion

Throws:

java.util.concurrent.RejectedExecutionException - if the task cannot be scheduled for execution

java.lang.NullPointerException - if command is null

schedule

<V> java.util.concurrent.ScheduledFuture<V> schedule(java.util.concurrent.Callable<V> callable,
                                                   Measurable<Duration> delay)

Creates and executes a ScheduledFuture that becomes enabled after the given delay.

Type Parameters:

V - the type of the callable's result

Parameters:

callable - the function to execute

delay - the time from now to delay execution

Returns:

a ScheduledFuture that can be used to extract result or cancel

Throws:

java.util.concurrent.RejectedExecutionException - if the task cannot be scheduled for execution

java.lang.NullPointerException - if callable is null

scheduleAtFixedRate

java.util.concurrent.ScheduledFuture<?> scheduleAtFixedRate(java.lang.Runnable command,
                                                          Measurable<Duration> initialDelay,
                                                          Measurable<Duration> period)

Creates and executes a periodic action that becomes enabled first after the given initial delay, and subsequently with the given period; that is executions will commence after initialDelay then initialDelay+period, then initialDelay + 2 * period, and so on. If any execution of the task encounters an exception, subsequent executions are suppressed. Otherwise, the task will only terminate via cancellation or termination of the executor. If any execution of this task takes longer than its period, then subsequent executions may start late, but will not concurrently execute.

Parameters:

command - the task to execute

initialDelay - the time to delay first execution

period - the period between successive executions

Returns:

a ScheduledFuture representing pending completion of the task, and whose get() method will throw an exception upon cancellation

Throws:

java.util.concurrent.RejectedExecutionException - if the task cannot be scheduled for execution

java.lang.NullPointerException - if command is null

java.lang.IllegalArgumentException - if period less than or equal to zero

scheduleWithFixedDelay

java.util.concurrent.ScheduledFuture<?> scheduleWithFixedDelay(java.lang.Runnable command,
                                                             Measurable<Duration> initialDelay,
                                                             Measurable<Duration> delay)

Creates and executes a periodic action that becomes enabled first after the given initial delay, and subsequently with the given delay between the termination of one execution and the commencement of the next. If any execution of the task encounters an exception, subsequent executions are suppressed. Otherwise, the task will only terminate via cancellation or termination of the executor.

Parameters:

command - the task to execute

initialDelay - the time to delay first execution

delay - the delay between the termination of one execution and the commencement of the next

Returns:

a ScheduledFuture representing pending completion of the task, and whose get() method will throw an exception upon cancellation

Throws:

java.util.concurrent.RejectedExecutionException - if the task cannot be scheduled for execution

java.lang.NullPointerException - if command is null

java.lang.IllegalArgumentException - if delay less than or equal to zero