javax.realtime.device

Class HappeningDispatcher

java.lang.Object

javax.realtime.ActiveEventDispatcher<HappeningDispatcher,Happening>

javax.realtime.device.HappeningDispatcher

public final class HappeningDispatcher
extends ActiveEventDispatcher<HappeningDispatcher,Happening>

This class provides a means of dispatching a set of Happening.

Since:

RTSJ 2.0

Constructor Summary

Constructors

Constructor and Description
HappeningDispatcher(SchedulingParameters schedule) Creates a new dispatcher, whose dispatching thread runs with the given scheduling parameters.
HappeningDispatcher(SchedulingParameters schedule, RealtimeThreadGroup group) Creates a new dispatcher, whose dispatching thread runs with the given scheduling parameters.

Method Summary

Modifier and Type	Method and Description
protected void	activate(Happening target) Activate an active event registered with this dispatcher.
protected void	deactivate(Happening target) Deactivate an active event registered with this dispatcher.
protected void	deregister(Happening target) Deregisters an active event from this dispatcher, breaking its association with this dispatcher.
void	destroy() Releases all resources thereby making the dispatcher unusable.
static HappeningDispatcher	getDefaultDispatcher() Gets the system default happening dispatcher.
boolean	isRegistered(Happening target) Test wether or not a given event is registered with this dispatcher.
protected void	register(Happening target) Registers an active event with this dispatcher.
static void	setDefaultDispatcher(HappeningDispatcher dispatcher) Sets the system default time dispatcher.

Methods inherited from class javax.realtime.ActiveEventDispatcher

getRealtimeThreadGroup, getScheduler, getSchedulingParameters, getThread, setScheduler, setScheduler, setSchedulingParameters

Methods inherited from class java.lang.Object

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

Constructor Detail

HappeningDispatcher

public HappeningDispatcher(SchedulingParameters schedule,
                           RealtimeThreadGroup group)
                    throws StaticIllegalStateException

Creates a new dispatcher, whose dispatching thread runs with the given scheduling parameters.

Throws:

StaticIllegalStateException - when the intersection of affinity in schedule and the affinity of group does not correspond to a valid affinity.

Parameters:

schedule - The parameters to use for scheduling this dispatcher.

group - The realtime thread group to use for the dispatcher.

HappeningDispatcher

public HappeningDispatcher(SchedulingParameters schedule)
                    throws StaticIllegalStateException

Creates a new dispatcher, whose dispatching thread runs with the given scheduling parameters.

Throws:

StaticIllegalStateException - when the intersection of affinity in schedule and the affinity of the current thread grouo does not correspond to a valid affinity.

Parameters:

schedule - The parameters to use for scheduling this dispatcher.

Method Detail

getDefaultDispatcher

public static HappeningDispatcher getDefaultDispatcher()

Gets the system default happening dispatcher.

setDefaultDispatcher

public static void setDefaultDispatcher(HappeningDispatcher dispatcher)

Sets the system default time dispatcher.

Throws:

UnsupportedOperationException - every time, since this is not implemented yet.

Parameters:

dispatcher - To be used when no dispatcher is provided. When null, the default time dispatcher is set to the original system default.

isRegistered

public boolean isRegistered(Happening target)

Test wether or not a given event is registered with this dispatcher.

Specified by:

isRegistered in class ActiveEventDispatcher<HappeningDispatcher,Happening>

Parameters:

target - The event to test

Returns:

true when event is registered with this dispatcher.

register

protected void register(Happening target)
                 throws RegistrationException,
                        StaticIllegalStateException

Registers an active event with this dispatcher. Registering an event prevents the event from being programmatically destroyed, but it may not hold the dispatcher from being collected when the dispatcher is in a more deeply nested scope.

Specified by:

register in class ActiveEventDispatcher<HappeningDispatcher,Happening>

Throws:

RegistrationException - when event is already registered.

StaticIllegalStateException - when this object has been destroyed.

Parameters:

target - The event to register

activate

protected void activate(Happening target)
                 throws StaticIllegalStateException

Activate an active event registered with this dispatcher.

Overrides:

activate in class ActiveEventDispatcher<HappeningDispatcher,Happening>

Throws:

StaticIllegalStateException - when event is stopped.

Parameters:

target - The event to register

deregister

protected void deregister(Happening target)
                   throws DeregistrationException,
                          StaticIllegalStateException

Deregisters an active event from this dispatcher, breaking its association with this dispatcher. This should only happen when an event is assoicated with another dispather.

Specified by:

deregister in class ActiveEventDispatcher<HappeningDispatcher,Happening>

Throws:

StaticIllegalStateException - when this object has been destroyed

DeregistrationException

Parameters:

target - The event to deregister

deactivate

protected void deactivate(Happening target)
                   throws StaticIllegalStateException

Deactivate an active event registered with this dispatcher.

Overrides:

deactivate in class ActiveEventDispatcher<HappeningDispatcher,Happening>

Throws:

StaticIllegalStateException - when this object has been destroyed.

Parameters:

target - The event to deregister

destroy

public void destroy()
             throws StaticIllegalStateException

Releases all resources thereby making the dispatcher unusable.

Specified by:

destroy in class ActiveEventDispatcher<HappeningDispatcher,Happening>

Throws:

StaticIllegalStateException - when called on a dispatcher that has one or more registered Happening objects.