fr.emn.reactiveinput
Interface Device

All Known Subinterfaces:

MutableDevice

All Known Implementing Classes:

AbstractDevice, AbstractMutableDevice, CompoundDevice, Pin

public interface Device

A device.

There are no subclass for input and output devices. Instead, hasExternalInput() and hasExternalOutput() methods are used to declare if the device has external (i.e. implicit) input or output.

DESIGN TIME :

EXECUTION TIME : init() -> update() -> update() -> udpate() ...

Never set values of output slots before the machine is running. Do this is in init() and update() methods.

Field Summary

static java.lang.String[]

AUTO_PROPERTIES

Method Summary

void	close() Closes the device.
Device	copy() Returns a new device with the same functionalities, or null if the device is not copiable (static device).
java.lang.String	getError() Returns a short description of the last error, if any.
DeviceInfo	getInfo() Optional user-oriented info.
In[]	getIns() Returns the device's input slots.
java.lang.String	getName() The short name of the device.
Out[]	getOuts() Returns the device's output slots.
java.lang.String[]	getProperties() Declares the device's properties, or returns AUTO_PROPERTIES if properties can be automatically deduced from accessor methods (in this case the order of properties as they appear in dialog box is not predictable).
boolean	hasExternalInput() Specifies whether this device has external (implicit) input or not.
boolean	hasExternalOutput() Specifies whether this device has external (implicit) output or not.
boolean	isCopiable() Returns true if the device is copiable (i.e. if copy() will not return null).
boolean	isOpenable() USE: Design.
Processor	open(OpenContext frame) Ensures that the device will be ready for processing or producing data, and returns the Processor object that will process data, or null if an error occured.
void	setEnabled(boolean enabled) Enables or disables the device.

Field Detail

AUTO_PROPERTIES

public static final java.lang.String[] AUTO_PROPERTIES

Method Detail

close

public void close()

Closes the device. Called when the device is not used any more.

Deallocate resources here.

copy

public Device copy()

Returns a new device with the same functionalities, or null if the device is not copiable (static device).

If your device has a no-arg contructor, use the default copy method provided in DeviceUtilities class.

Note: the copied device must return the same original prototype as the source device. See getPrototype() and setPrototype() methods in DeviceUtilities.

getError

public java.lang.String getError()

Returns a short description of the last error, if any. This method is usually called after an open has failed.

getInfo

public DeviceInfo getInfo()

Optional user-oriented info. See DeviceInfo interface.

getIns

public In[] getIns()

Returns the device's input slots.

getName

public java.lang.String getName()

The short name of the device.

getOuts

public Out[] getOuts()

Returns the device's output slots.

getProperties

public java.lang.String[] getProperties()

Declares the device's properties, or returns AUTO_PROPERTIES if properties can be automatically deduced from accessor methods (in this case the order of properties as they appear in dialog box is not predictable).

All declared properties must be accessible through setXXX and getXXX accessor methods.

Example: If your device has the "Value" property of integer type, you must implement the "int getValue()" and "void setValue(int)" methods. Note: Property names are case-sensitive.

Currently supported types are:

hasExternalInput

public boolean hasExternalInput()

Specifies whether this device has external (implicit) input or not.

Returns false if the device is deterministic from the data & time points of view, i.e. if its output production only depend on the explicit input history (input slots) and device's initial configuration. This is the case of most of the processing devices.

Return trues if output values do not only depend on the values of input slots, or if output production takes undefined time. Examples of devices with external input are input peripherals and asynchronous devices.

This method is used by the reactive machine to determine if this device is triggered by its input slots, or if it must be triggered continuously (i.e. each tick). This method can also be used by the editor for the device's graphical representation.

hasExternalOutput

public boolean hasExternalOutput()

Specifies whether this device has external (implicit) output or not.

Return false if the device has no border effects. Most of input and processing devices are in this case.

Return true if the device has border effects, such as graphical feedback, or control of some external value. Examples of devices with external output are application-interfacing devices and all user feedback devices.

This method can be used by the editor for the device's graphical representation. However this makes no difference for the reactive machine.

isCopiable

public boolean isCopiable()

Returns true if the device is copiable (i.e. if copy() will not return null).

isOpenable

public boolean isOpenable()

USE: Design.

This method returns false if the device is not openable because it is not properly configured (e.g. important input slots are not connected). Reactive machines ignore devices that are not openable.

Use this method if you want some pre-conditions to be verified before the execution of your device, inside init() and update() methods.

In the default method provided in DeviceUtilities, isOpenable() returns false if one or several obligatory input slots are not valid (see In.isValid()). You may add your own pre-conditions to this method.

Example :

public boolean isOpenable() { if (DeviceUtilities.defaultIsOpenable(this)) { // Verify default pre-conditions if (...) // Put additional pre-conditions here return true; } return false; }

open

public Processor open(OpenContext frame)

Ensures that the device will be ready for processing or producing data, and returns the Processor object that will process data, or null if an error occured.

Some devices may need to perform some more or less heavy initialization (such as allocating resources or opening a stream) before being able to process or produce data. This is the case for most input devices, and some I/O and output devices. All these initializations must be done in the open() method.

Because these initializations are subject to fail, open() may return null even if isOpenable() returns true. In all cases, returning a non-null Processor means that the device is now able to process or produce data.

RE-OPENING A DEVICE:

Devices always stay open during reconfiguration, in order to avoid unnecessary deallocation and reallocation of resources. However, some devices will need to be re-open before re-starting the configuration. So open() is always called on all devices before re-starting.

If open() is called on a device that is already open, it may have no effect (and the current Processor is returned), or the device may be re-open if something has changed in its configuration.

Using a Processor as a return value allows the use of different processors, each adapted to a specific device configuration.

Returns:

a Processor if the device is openable and has been successfully open, null otherwise.

OPEN CONTEXT:

Some devices may need a context to open. For example, devices that display themselves on a swing window will need a JFrame as context. Context is handled by OpenContext class.

See Also:

Processor

setEnabled

public void setEnabled(boolean enabled)

Enables or disables the device.