Module org.autogui

Package org.autogui.base.mapping

Class ScheduledTaskRunner<EventType>

java.lang.Object

org.autogui.base.mapping.ScheduledTaskRunner<EventType>

Direct Known Subclasses:

EditingRunner

public class ScheduledTaskRunner<EventType>
extends Object

a delayed task executor accumulating subsequent firing events while the specified delay

      ScheduledTaskRunner<E> r = new ScheduledTaskRunner<>(300, runner);
      r.schedule(e1); //start a task with waiting 300 msec
      r.schedule(e2); //cancel the previous task and start another new task with waiting 300 msec
      sleep(300);
      //the runner will be dispatched with a list of [e1, e2]
  

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static class	ScheduledTaskRunner.DepthStack	debug features for task-running: the system-property org.autogui.base.mapping.debugDepth can be err : specifies the output to System.err, or a file-path : specifies the output to the file.
static class	ScheduledTaskRunner.TaskWithContext<T>	a task wrapper for ScheduledTaskRunner.DepthStack

Field Summary

Fields

Modifier and Type	Field	Description
protected List<EventType>	accumulatedEvents
protected Consumer<List<EventType>>	consumer
protected long	delay	msec
protected static ScheduledTaskRunner.DepthStack	depthStack	non-null depth-stack
protected boolean	enabled
protected ScheduledExecutorService	executor
protected boolean	executorIsShared	true if the executor is sharedExecutor.
protected ScheduledFuture<?>	scheduledTask
static AtomicInteger	sharedCount
static ScheduledExecutorService	sharedExecutor

Constructor Summary

Constructors

Constructor	Description
ScheduledTaskRunner(long delay, Consumer<List<EventType>> consumer)	creates a new task-runner with sharedExecutor.
ScheduledTaskRunner(long delay, Consumer<List<EventType>> consumer, ScheduledExecutorService executor)

Method Summary

Modifier and Type	Method	Description
static Runnable	depthRunner(Runnable r)
static <T> Callable<T>	depthRunner(Callable<T> r)
static <T> Supplier<T>	depthRunner(Supplier<T> r)
Consumer<List<EventType>>	getConsumer()
long	getDelay()
ScheduledExecutorService	getExecutor()
static ScheduledExecutorService	getSharedExecutor()
void	handleException(Throwable ex)
boolean	hasScheduledTask()
protected boolean	initEnabled()
void	run()
static void	runForShared(Runnable task)	execute a task with synchronization for handling sharedExecutor
void	runImmediately(EventType event)
void	schedule(EventType event)
void	schedule(EventType event, long delayMSec)	if enabled, schedules a task for processing the event.
void	setConsumer(Consumer<List<EventType>> consumer)
void	setDelay(long delay)
void	setEnabled(boolean enabled)
protected void	setExecutor(ScheduledExecutorService executor)	init the executor to the runner.
void	shutdown()
static void	withDepthInfo(String info, Runnable body)
static <T> T	withDepthInfo(String info, Callable<T> body)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Details

delay

protected long delay

msec

executor

protected ScheduledExecutorService executor

executorIsShared

protected boolean executorIsShared

true if the executor is sharedExecutor.

Since:

1.2

consumer

protected Consumer<List<EventType>> consumer

accumulatedEvents

protected List<EventType> accumulatedEvents

scheduledTask

protected ScheduledFuture<?> scheduledTask

enabled

protected volatile boolean enabled

sharedExecutor

public static ScheduledExecutorService sharedExecutor

sharedCount

public static AtomicInteger sharedCount

depthStack

protected static ScheduledTaskRunner.DepthStack depthStack

non-null depth-stack

Constructor Details

ScheduledTaskRunner

public ScheduledTaskRunner(long delay,
 Consumer<List<EventType>> consumer)

creates a new task-runner with sharedExecutor.

Parameters:

delay - the delay milliseconds for launching a task

consumer - the actual task runner as taking accumulated events

ScheduledTaskRunner

public ScheduledTaskRunner(long delay,
 Consumer<List<EventType>> consumer,
 ScheduledExecutorService executor)

Method Details

initEnabled

protected boolean initEnabled()

setExecutor

protected void setExecutor(ScheduledExecutorService executor)

init the executor to the runner. if the executor is sharedExecutor, executorIsShared becomes true. Basically the executor will not be changed, but shutdown() might cause renewal of sharedExecutor. Then schedule(Object, long) will call the method again for obtaining a new sharedExecutor.

Parameters:

executor - the executor to be set

Since:

1.2

runForShared

public static void runForShared(Runnable task)

execute a task with synchronization for handling sharedExecutor

Parameters:

task - a task with synchronization

Since:

1.2

getSharedExecutor

public static ScheduledExecutorService getSharedExecutor()

getConsumer

public Consumer<List<EventType>> getConsumer()

setConsumer

public void setConsumer(Consumer<List<EventType>> consumer)

getDelay

public long getDelay()

setDelay

public void setDelay(long delay)

schedule

public void schedule(EventType event)

schedule

public void schedule(EventType event,
 long delayMSec)

if enabled, schedules a task for processing the event. if another task is already scheduled, then the old task will be canceled. So, subsequent tasks cause extending the delayed time.

If the executor have been shutdown and the executor is the sharedExecutor, then it will obtain a new shared executor by getSharedExecutor(). This means the method causes reincarnation of the shared executor.

Parameters:

event - an accumulated event processed by a delayed task

delayMSec - delaying milliseconds

withDepthInfo

public static void withDepthInfo(String info,
 Runnable body)

See Also:

• ScheduledTaskRunner.DepthStack.withDepthInfo(String, Runnable)

withDepthInfo

public static <T> T withDepthInfo(String info,
 Callable<T> body)
                           throws Exception

Throws:

Exception

See Also:

• ScheduledTaskRunner.DepthStack.withDepthInfo(String, Callable)

depthRunner

public static Runnable depthRunner(Runnable r)

See Also:

• ScheduledTaskRunner.DepthStack.depthRunner(Runnable)

depthRunner

public static <T> Callable<T> depthRunner(Callable<T> r)

See Also:

• ScheduledTaskRunner.DepthStack.depthRunner(Callable)

depthRunner

public static <T> Supplier<T> depthRunner(Supplier<T> r)

See Also:

• ScheduledTaskRunner.DepthStack.depthRunner(Supplier)

runImmediately

public void runImmediately(EventType event)

run

public void run()

handleException

public void handleException(Throwable ex)

setEnabled

public void setEnabled(boolean enabled)

getExecutor

public ScheduledExecutorService getExecutor()

shutdown

public void shutdown()

hasScheduledTask

public boolean hasScheduledTask()

Returns:

true if it has awaiting task

Since:

1.3