Serialized Form

Package org.logicmachine.rebl.domain.exceptions

Exception Class org.logicmachine.rebl.domain.exceptions.BusinessMessage

class BusinessMessage extends RuntimeException implements Serializable

serialVersionUID:

5071488431065017472L

Serialized Fields

isHandled

boolean isHandled

Flag indicating if this business exception has been handled by an exception handler.

Once an exception handler has flagged an exception as being handled, no further exception handlers will be invoked to service it.

Exception Class org.logicmachine.rebl.domain.exceptions.EmptyOrNullArgumentException

class EmptyOrNullArgumentException extends IllegalArgumentException implements Serializable

serialVersionUID:

-4412289285085993201L

Serialized Fields

message

String message

Holds the message details for this exception.

Package org.logicmachine.rebl.domain.stateMachines

Class org.logicmachine.rebl.domain.stateMachines.StateMachine

class StateMachine extends Entity implements Serializable

serialVersionUID:

9222037501428883106L

Serialization Methods

readObject

private void readObject(ObjectInputStream stream)
                 throws IOException,
ClassNotFoundException

Reads the next available object from the input stream, as per the Serialization contract.

Note the current implementation just provides the default behaviour, but is left for future modification.

Parameters:

stream - handle to the input stream

Throws:

IOException - on read error

ClassNotFoundException - on deserialisation error

writeObject

private void writeObject(ObjectOutputStream stream)
                  throws IOException

Writes the object to the output stream, as per the Serialization contract.

Note the current implementation just provides the default behaviour, but is left for future modification.

Parameters:

stream - handle to the output stream

Throws:

IOException - on write error

Serialized Fields

currentState

Enum<?> currentState

Holds the current state of this state machine.

debugAnnounce

boolean debugAnnounce

Aids debugging by announcing state changes to the standard output stream.

entryActions

Map<T extends Enum<T>,Collection<Action>> entryActions

Holds any (optional) actions to be applied when entering a given destination state.

The index is the current state and the value is the collection of actions to be invoked when transitioning into that particular destination state.

Note that entry actions are NOT invoked for any transition from any super state to any other state. In such cases, resume actions will be invoked for the destination state.

exitActions

Map<T extends Enum<T>,Collection<Action>> exitActions

Holds any (optional) actions to be applied when leaving a given source state.

The index is the current state and the value is the collection of actions to be invoked when transitioning out of that particular source state.

Note that exit actions are NOT invoked for any transition from a state to any super state. In such cases, suspend actions will be invoked for the original source state.

initialState

Enum<?> initialState

Holds the initial starting state of this state machine, allowing this state machine to be subsequently reset.

previousState

Enum<?> previousState

Holds the previous state of this state machine.

This may prove useful within triggered Actions to allow determination of the transition arc, from state A to state B.

resumeActions

Map<T extends Enum<T>,Collection<Action>> resumeActions

Holds any (optional) actions to be applied when resuming a given state from a super state.

The index is the current state and the value is the collection of actions to be invoked when transitioning from a super state to that state.

states

Map<T extends Enum<T>,List<T extends Enum<T>>> states

Holds the permitted state transitions for this finite state machine instance.

The key is the 'current' state, and the value is the list of states to which it is permissible to transition from this particular source state. Trying to transition from this state to any other states will generate an error (with the exception of any super states, which are always permitted from any other state, without requiring any explicit transition configuration).

superStates

List<T extends Enum<T>> superStates

Holds the states which are directly available from any other state without requiring explicit configuration of such state transition.

suspendActions

Map<T extends Enum<T>,Collection<Action>> suspendActions

Holds any (optional) actions to be applied when suspending a given source state for a transition into a super state.

The index is the current state and the value is the collection of actions to be invoked when transitioning into a super state from that source state.

Package org.logicmachine.rebl.domain.transactions

Class org.logicmachine.rebl.domain.transactions.ScopedTransaction

class ScopedTransaction extends KeyValue implements Serializable

serialVersionUID:

-7737583852065939789L

Serialization Methods

readObject

private void readObject(ObjectInputStream stream)
                 throws IOException,
ClassNotFoundException

Reads the next available object from the input stream.

Required as per the Serialization contract.

Parameters:

stream - handle to the input stream

Throws:

IOException - on read error

ClassNotFoundException - on deserialisation error

writeObject

private void writeObject(ObjectOutputStream stream)
                  throws IOException

Writes the object to the output stream.

Required as per the Serialization contract.

Parameters:

stream - handle to the output stream

Throws:

IOException - on write error

Serialized Fields

isGlobalTransaction

boolean isGlobalTransaction

This flag will be true if this transaction represents an outer global transaction, or false if this represents an inner local transaction.

resources

List<TransactionResource> resources

Holds the list of resources enlisted for this transaction.

setRollbackOnly

boolean setRollbackOnly

This flag is set to true by calling the 'setRollbackOnly()' method.

Once this flag has been set to true, the only possible outcome of this transaction is to roll back the transaction.

This flag defaults to false.

synchronisationObject

javax.transaction.Synchronization synchronisationObject

If non-null, the 'beforeCompletion() method on this instance will be invoked prior to starting the two-phase commit process. Then after the transaction is completed, the 'afterCompletion()' method on this instance will be invoked.

transactionAwareScope

TransactionAwareScope transactionAwareScope

Reference back to the enclosing transactionAwareScope which created this transaction.

Note that the transaction manager will be this same enclosing Scope instance since TransactionAwareScope implements the TransactionManager interface.

transactionId

XidImpl transactionId

Holds the unique transaction ID for this instance.

transactionStatus

StateMachine<TransactionStatus> transactionStatus

Holds the status of this transaction.

Note that initially the status of this state machine will be 'TransactionStatus.NOT_STARTED'.

transactionTimeoutInSeconds

int transactionTimeoutInSeconds

Holds the duration (in seconds) after which this transaction will timeout.

This defaults to the system transaction timeout period.