Index (rebl.core 1.0 API)

A B C D E F G H I J K L M N O P R S T U V W X
All Classes and Interfaces|All Packages|Constant Field Values|Serialized Form

A

AbstractTransactionAwareScope<T,U> - Class in org.logicmachine.rebl.domain.transactions.managers: Nested scopes provide isolation for blocks of business logic.
AbstractTransactionAwareScope() - Constructor for class org.logicmachine.rebl.domain.transactions.managers.AbstractTransactionAwareScope: Default constructor.
AbstractTransactionAwareScope(String) - Constructor for class org.logicmachine.rebl.domain.transactions.managers.AbstractTransactionAwareScope: Constructor creating a new scope instance of the given 'scopeName'.
AbstractTransactionAwareScope(String, boolean) - Constructor for class org.logicmachine.rebl.domain.transactions.managers.AbstractTransactionAwareScope: Constructor creating a new scope instance of the given 'scopeName'.
accept(File, String) - Method in class org.logicmachine.rebl.domain.transactions.managers.TransactionLogFilenameFilter: Tests if the given 'filename' within the given 'directory' belongs to this scope instance.
ACQUIESCED - Enum constant in enum class org.logicmachine.rebl.monitor.health.HealthStatus: Indicates that some attribute associated with this entity has acquiesced.
Action - Class in org.logicmachine.rebl.domain.actions: An Action can be applied to any ActiveEntity.
Action() - Constructor for class org.logicmachine.rebl.domain.actions.Action: Default constructor.
Action(String) - Constructor for class org.logicmachine.rebl.domain.actions.Action: Constructor creating an instance associated with the given 'key'.
Action.EmptyAction - Class in org.logicmachine.rebl.domain.actions: Simple no-op action implementation.
Actions - Class in org.logicmachine.rebl.domain.actions: Collection class holding a set of Action instances.
Actions() - Constructor for class org.logicmachine.rebl.domain.actions.Actions: Default constructor.
active() - Static method in class org.logicmachine.rebl.monitor.health.Health: Convenience method which can be used to create a health status of 'ACTIVE'.
ACTIVE - Enum constant in enum class org.logicmachine.rebl.monitor.health.HealthStatus: Indicates that some underlying entity is both up and running and is in an active state.
ACTIVE_ACTOR - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the name used as a label for the active actor within a scope.
ACTIVE_ENTITY - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the name used as a label for the active entity within a scope.
ACTIVE_RESOURCE - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the name used as a label for the active resource within a scope.
activeActor - Variable in class org.logicmachine.rebl.language.context.Scope: This is a placeholder for the currently active actor.
activeEntity - Variable in class org.logicmachine.rebl.language.context.Scope: This is a placeholder for the currently active entity.
ActiveEntity - Class in org.logicmachine.rebl.domain.entities: ActiveEntities are owned by OwningEntities (also known as Actors).
ActiveEntity() - Constructor for class org.logicmachine.rebl.domain.entities.ActiveEntity: Default constructor.
ActiveEntity(Object) - Constructor for class org.logicmachine.rebl.domain.entities.ActiveEntity: Constructor creating an instance associated with the given 'key'.
ActiveEntity(Object, Scope) - Constructor for class org.logicmachine.rebl.domain.entities.ActiveEntity: Constructor creating an instance associated with the given 'key'.
activeExceptionHandler - Variable in class org.logicmachine.rebl.language.context.Scope: This is a placeholder for the exception hanlder which is currently processing the caught exception within this scope instance.
activeResource - Variable in class org.logicmachine.rebl.language.context.Scope: This is a placeholder for the currently active resource.
Actor - Class in org.logicmachine.rebl.domain.actors: An Actor is an entity which has ownership of some ActiveEntity.
Actor() - Constructor for class org.logicmachine.rebl.domain.actors.Actor: Default constructor.
Actors - Class in org.logicmachine.rebl.domain.actors: Collection class holding a set of Actor instances.
Actors() - Constructor for class org.logicmachine.rebl.domain.actors.Actors: Default constructor.
add(Object) - Method in class org.logicmachine.rebl.language.context.EnvironmentObjects: Adds the input 'object' unchanged to the current operating environment if 'object' is an instance of EnvironmentObject, otherwise this method will construct a new EnvironmentObject instance from the given 'object' and add this new instance to the current operating environment.
add(Action) - Method in class org.logicmachine.rebl.domain.actions.Actions
add(Actor) - Method in class org.logicmachine.rebl.domain.actors.Actors
add(Entity) - Method in class org.logicmachine.rebl.domain.entities.Entities
add(ExceptionHandler) - Method in class org.logicmachine.rebl.domain.exceptions.ExceptionHandlers
add(Resource) - Method in class org.logicmachine.rebl.domain.resources.Resources
add(StateMachine<?>) - Method in class org.logicmachine.rebl.domain.stateMachines.StateMachines
add(EnvironmentObject) - Method in class org.logicmachine.rebl.language.context.EnvironmentObjects: Adds the given 'object' to the current operating environment.
add(Monitor<?>) - Method in class org.logicmachine.rebl.monitor.Monitors
add(T) - Method in class org.logicmachine.rebl.common.Many
add(T) - Method in class org.logicmachine.rebl.common.SafeIterable: Adds the specified object to the underlying Collection, provided the underlying Collection is non-null.
add(T) - Method in class org.logicmachine.rebl.common.Some: This method allows the given 'entity' to be added to the current collection.
addAll(Object...) - Static method in class org.logicmachine.rebl.language.context.EnvironmentObjects: Returns a newly created EnvironmentObjects collection, holding the given 'objects', each of which will have been wrapped in an 'EnvironmentObject' instance before being added to the collection.
addAll(Collection<T>) - Method in class org.logicmachine.rebl.common.Many
addAll(Collection<T>) - Method in class org.logicmachine.rebl.common.Some: Adds all of the given 'entities' to the collection associated with this instance.
addAll(EnvironmentObject...) - Method in class org.logicmachine.rebl.language.context.EnvironmentObjects: Adds the given 'objects' to the current operating environment.
addAll(T...) - Method in class org.logicmachine.rebl.common.Many
addAll(T...) - Method in class org.logicmachine.rebl.common.Some: Adds all of the given 'entities' to the collection associated with this instance.
addExceptionMapping(Class<? extends Exception>, T) - Method in class org.logicmachine.rebl.domain.stateMachines.StateMachineExceptionHandler: This method allows a mapping to be created, causing an exception of type 'exceptionClass' to trigger a state transition to the given 'exceptionState'.
addIfPopulated(StringBuilder, int, String, Object) - Static method in class org.logicmachine.rebl.language.context.Scope: Appends the given 'header' to the specified 'stringBuilder', suitably indented to the given 'indentationLevel'.
ADDRESS_REGEX - Static variable in class org.logicmachine.rebl.common.Constants: Regular-expression used to match memory address locations within the 'toString()' method associated with PreparedStatements.
addToGlobalScope(Class<? extends Entity>, Entities) - Method in class org.logicmachine.rebl.language.Language: Adds the 'entities' of the specified 'clazz' to the global scope.
addToPool(boolean) - Method in class org.logicmachine.rebl.common.Pool: This method is used to add new entries (constructed by calling the 'createNewEntry()' method) to the pool.
addToScope(Class<? extends Entity>, Entities) - Method in class org.logicmachine.rebl.language.context.Scope: Adds the business 'entities' of the specified 'clazz' to the current scope.
afterApply(boolean) - Method in class org.logicmachine.rebl.domain.entities.ActiveEntity: Placeholder method hook which is invoked immediately prior to exiting the 'apply()' method.
afterIteration(ResponseCode) - Method in class org.logicmachine.rebl.domain.entities.ActiveEntity: Placeholder method hook which is invoked immediately after each iteration of the 'Repeatable' code block (but before any sleep time defined within the Repeatable object has been applied).
allowNull - Variable in class org.logicmachine.rebl.common.Some: If true, the 'find()' method will return null on no match.
allowNull() - Method in class org.logicmachine.rebl.common.Some: By default, the 'find()' method will return a non-null 'empty' instance on no match.
allScopes - Variable in class org.logicmachine.rebl.domain.resources.Resource: Holds the list of Scope instances to which this Resource has been associated.
appendAlignedNameValuePairs(StringBuilder, int, int, Object...) - Static method in class org.logicmachine.rebl.common.Common: This method will iterate over the given 'nameValuePairs' and align the given field name within a field of size 'maxFieldWidth' before appending a "colon space" character sequence followed by the given (optional) 'value' (which can be null) followed by a newline character.
appendAlignedNameValuePairsWithVerticalSpace(StringBuilder, int, int, Object...) - Static method in class org.logicmachine.rebl.common.Common: This method will iterate over the given 'nameValuePairs' and align the given field name within a field of size 'maxFieldWidth' before appending a "colon space" character sequence followed by the given (optional) 'value' (which can be null) followed by a newline character.
apply() - Method in class org.logicmachine.rebl.domain.entities.ActiveEntity: Applies all previously defined actions within the current namespace to this ActiveEntity instance, invoking the various 'before()', 'after()' and 'on()' hook methods.
applyThis() - Method in class org.logicmachine.rebl.domain.entities.ActiveEntity: Applies all previously defined actions to this ActiveEntity instance, invoking the various 'before()', 'after()' and 'on()' hook methods as well as any monitoring hooks.
applyThisAction(Action) - Method in class org.logicmachine.rebl.domain.entities.ActiveEntity: Immediately and directly applies the given action to this ActiveEntity instance.
applyThisTransaction(TransactionDetails) - Method in class org.logicmachine.rebl.domain.transactions.resources.impl.InMemoryXAResource: Applies the given CRUD operation to the in-memory store.
arguments() - Method in class org.logicmachine.rebl.domain.actions.Callable: Returns the (optional) arguments to be passed into the method call during invocation.
ARROW - Static variable in class org.logicmachine.rebl.common.Constants: Holds the character sequence used as a separator within 'toString()' methods to separate key/value pairs.
assignActiveEntity(ActiveEntity) - Method in class org.logicmachine.rebl.domain.entities.OwningEntity: This method will cross-reference the given 'activeEntity' with the scope associated with this OwningEntity.
assignActiveEntityToScope() - Method in class org.logicmachine.rebl.domain.actors.Actor: Assigns the response returned from the 'getActiveEntity()' method to the scope associated with this Actor.
attribute() - Method in class org.logicmachine.rebl.domain.transactions.attributes.TransactionDetails: Returns the (first) attribute added.
attributes() - Method in class org.logicmachine.rebl.domain.transactions.attributes.TransactionDetails: Returns the (optional) attributes associated with this entity.
available - Variable in class org.logicmachine.rebl.common.Pool: The list of free/available pool entries.

B

beforeApply() - Method in class org.logicmachine.rebl.domain.entities.ActiveEntity: Placeholder method hook which is invoked on entry to the 'apply()' method.
beforeIteration() - Method in class org.logicmachine.rebl.domain.entities.ActiveEntity: Placeholder method hook which is invoked before the start of each iteration of the 'Repeatable' code block.
begin() - Method in class org.logicmachine.rebl.domain.transactions.managers.AbstractTransactionAwareScope: Creates a new local transaction which will share the same global transaction as the currently active transaction.
begin(Xid) - Method in class org.logicmachine.rebl.domain.transactions.resources.TransactionResource: Starts work on behalf of the given transaction.
BEGIN_NEW_GLOBAL_TRANSACTION - Static variable in class org.logicmachine.rebl.domain.transactions.managers.AbstractTransactionAwareScope: Used to set a flag indicating that a new global transaction is required.
beginNewGlobalTransaction() - Method in class org.logicmachine.rebl.domain.transactions.managers.AbstractTransactionAwareScope: Actually starts a new global transaction.
beginNewGlobalTransaction() - Method in class org.logicmachine.rebl.domain.transactions.managers.JdbcTransactionAwareScope
beginNewGlobalTransaction() - Method in class org.logicmachine.rebl.domain.transactions.managers.TransactionAwareScope
beginNewLocalTransaction() - Method in class org.logicmachine.rebl.domain.transactions.managers.AbstractTransactionAwareScope: Top-level entry-point into the functionality required to actually start a new local transaction, which will share the currently active global transaction.
beginNewTransaction(boolean) - Method in class org.logicmachine.rebl.domain.transactions.managers.AbstractTransactionAwareScope: Top-level entry-point into the functionality required to actually start a new transaction.
beginNewTransaction(boolean) - Method in class org.logicmachine.rebl.domain.transactions.managers.JdbcTransactionAwareScope: This method will begin a new transaction.
beginNewTransaction(boolean) - Method in class org.logicmachine.rebl.domain.transactions.managers.TransactionAwareScope
beginTransaction() - Method in class org.logicmachine.rebl.domain.entities.ActiveEntity: This method forms a placeholder for any transaction initialisation activity.
beginTransaction() - Method in class org.logicmachine.rebl.domain.transactions.managers.AbstractTransactionAwareScope: Creates a new global transaction and adds it to the transaction stack.
beginTransaction() - Method in class org.logicmachine.rebl.language.context.Scope: This method forms a placeholder for any transaction initialisation.
beginTransaction() - Method in interface org.logicmachine.rebl.language.details.Vocabulary: This method forms a placeholder for any transaction initialisation activity.
branch - Variable in class org.logicmachine.rebl.domain.transactions.managers.TransactionAwareWithWriteAheadScope: Holds the branch qualifier of the current transaction.
buildArray(int, Long...) - Static method in class org.logicmachine.rebl.domain.transactions.attributes.impl.XidImpl: Helper method which returns a byte array of the specified 'size', holding the given 'values'.
businessEntities - Variable in class org.logicmachine.rebl.language.context.Scope: Holds the optional business entities which are only visible within the current scope.
BusinessMessage - Exception Class in org.logicmachine.rebl.domain.exceptions: This class forms the base-class for all business exceptions.
BusinessMessage() - Constructor for exception class org.logicmachine.rebl.domain.exceptions.BusinessMessage: Default constructor.
BusinessMessage(Exception) - Constructor for exception class org.logicmachine.rebl.domain.exceptions.BusinessMessage: This constructor allows standard Exception instances to be wrapped.
BusinessMessage(String) - Constructor for exception class org.logicmachine.rebl.domain.exceptions.BusinessMessage: Constructor, allowing an error message to be defined.
BusinessMessage(String, Exception) - Constructor for exception class org.logicmachine.rebl.domain.exceptions.BusinessMessage: This constructor allows standard Exception instances to be wrapped.
BusinessMessage(String, String) - Constructor for exception class org.logicmachine.rebl.domain.exceptions.BusinessMessage: Constructor, allowing an error message to be defined along with an (optional) 'messagePrefix' which will not be included within the actual exception but which will be prepended to the 'errorMessage' prior to being logged.

C

calculatePoolIncrementSize(int) - Static method in class org.logicmachine.rebl.common.Pool: This method determines the poolIncrementSize as a fraction of the specified 'initialPoolSize' parameter.
Callable - Class in org.logicmachine.rebl.domain.actions: This class allows 'Callable' statements to participate in the Actions which can be applied to an ActiveEntity instance.
Callable() - Constructor for class org.logicmachine.rebl.domain.actions.Callable: Default constructor.
Callable(String) - Constructor for class org.logicmachine.rebl.domain.actions.Callable: Constructor allowing a callable 'name' to be defined.
Callable(String, Object...) - Constructor for class org.logicmachine.rebl.domain.actions.Callable: Constructor allowing a callable 'name' to be defined along with parameter values.
Callable(String, ActiveEntity) - Constructor for class org.logicmachine.rebl.domain.actions.Callable: Constructor allowing a callable 'name' to be defined.
Callable(String, ActiveEntity, Object...) - Constructor for class org.logicmachine.rebl.domain.actions.Callable: Constructor allowing a callable 'name' to be defined along with parameter values and the 'activeEntity' on which this callable will be invoked.
canChangeToState(Enum<?>) - Method in class org.logicmachine.rebl.domain.stateMachines.StateMachine: Returns true if it is possible to transition from the current state of this state machine to the specified 'newState'.
canHandle(Exception) - Method in class org.logicmachine.rebl.domain.exceptions.ExceptionHandler: If any ExceptionFilters have been defined for this exception handler instance, this method will only return true if at least one filter matches the given 'exception'.
changeState(Enum<?>) - Method in class org.logicmachine.rebl.domain.stateMachines.StateMachine: Attempts to transition from the current state to the 'newState', returning true if this transition is permitted; false otherwise.
checkForParallelEnvironmentVariable(Scope) - Static method in class org.logicmachine.rebl.language.context.Scope: Sets the given 'scope' to run in parallel mode if the corresponding system environment variable ("__LM_PARALLEL_SCOPE_MODE") has been set to true or if a similar key/value pair has been added to the environment objects associated with this 'scope'.
CLASS_METHOD_SEPARATOR - Static variable in class org.logicmachine.rebl.common.Constants: Holds the character sequence used to separate the class name and method name values when concatenated together within a string.
clear() - Method in class org.logicmachine.rebl.common.Many
clear() - Method in class org.logicmachine.rebl.common.Pool: This method will release the 'inUse', 'available' and 'pool' list entries.
clear() - Method in class org.logicmachine.rebl.common.ScopeAssignable: Deletes all data held within this ScopeAssignable instance.
clear() - Method in class org.logicmachine.rebl.common.Some: Removes all elements from this collection.
clear() - Method in class org.logicmachine.rebl.domain.stateMachines.StateMachine: Resets this state machine to the initial state and removes all entry and exit actions.
clear() - Method in class org.logicmachine.rebl.domain.transactions.managers.AbstractTransactionAwareScope: Attempts to commit any open transactions (automatically rolling back any transactions which fail to commit), then closes any CloseableResources and finally clears all data associated with this scope.
clear() - Method in class org.logicmachine.rebl.domain.transactions.managers.JdbcTransactionAwareScope
clear() - Method in class org.logicmachine.rebl.domain.transactions.resources.impl.InMemoryXAResource: Clears all internal data.
clear() - Method in class org.logicmachine.rebl.language.context.Scope: Closes any CloseableResources and clears all data associated with this scope.
clearActionsInCurrentNameSpace() - Method in class org.logicmachine.rebl.domain.entities.ActiveEntity: Clears all existing Actions in the current namespace in preparation for the addition of new Actions to be applied to this ActiveEntity instance.
clearGlobalScopeEntities() - Method in class org.logicmachine.rebl.language.Language: Removes all of the entities stored within the global scope.
clearParallelActiveEntities() - Method in class org.logicmachine.rebl.language.Language: Clears the collection of parallel active entities (for all scopes).
clearScopes() - Static method in class org.logicmachine.rebl.common.Common: Clears the data associated with all known scope instances.
CLOSABLE_RESOURCE_NOT_INHERITED - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the string used to warn that a closeable resource instance from a parent scope has NOT been inherited by a child scope.
close() - Method in class org.logicmachine.rebl.domain.resources.CloseableResource
close() - Method in class org.logicmachine.rebl.domain.transactions.ScopedTransaction: Closes this transaction, committing (if necessary) before delisting any resources held by this transaction.
CLOSE_PARENTHESIS - Static variable in class org.logicmachine.rebl.common.Constants: Hold the close-round-bracket character.
CLOSEABLE_RESOURCE_ERROR_ON_CLOSE - Static variable in class org.logicmachine.rebl.common.i18n.ErrorMessages: Holds the error message generated if an exception is caught when trying to automatically close a CloseableResource instance.
CloseableResource - Class in org.logicmachine.rebl.domain.resources: A CloseableResource is a special type of Resource which requires some clean-up activities to be performed prior to shutdown.
CloseableResource() - Constructor for class org.logicmachine.rebl.domain.resources.CloseableResource: Default constructor.
closeAllOpenTransactions() - Method in class org.logicmachine.rebl.domain.transactions.managers.AbstractTransactionAwareScope: Attempts to commit all currently open transactions.
closeAndDeleteFile(RandomAccessFile, File) - Method in class org.logicmachine.rebl.domain.transactions.managers.TransactionAwareWithWriteAheadScope: Closes and deletes the given transaction log file.
closeResource() - Method in class org.logicmachine.rebl.domain.resources.CloseableResource: All CloseableResource instances must define this method, which will be called automatically to initiate the clean-up activities prior to closing the corresponding scope.
closeResource() - Method in class org.logicmachine.rebl.domain.transactions.resources.impl.InMemoryXAResource
closeResource() - Method in class org.logicmachine.rebl.domain.transactions.resources.TransactionResource: Closes this resource, committing any outstanding branches for all global transactions known to this resource.
closeScope() - Method in class org.logicmachine.rebl.domain.transactions.managers.TransactionAwareWithWriteAheadScope: Clears all data associated with the current scope.
closeScope() - Method in class org.logicmachine.rebl.language.context.Scope: This method closes the current scope provided this scope is the default scope or this scope has not been flagged as parallel.
closeThisScope() - Method in class org.logicmachine.rebl.domain.transactions.managers.AbstractTransactionAwareScope: Clears all data associated with the current scope.
closeThisScope() - Method in class org.logicmachine.rebl.language.context.Scope: In general, to close a sequential scope, call the 'closeScope()' method.
closeTransactionLog() - Method in class org.logicmachine.rebl.domain.transactions.managers.TransactionAwareWithWriteAheadScope: Closes the file holding the write-ahead transaction log used by this instance.
COLON - Static variable in class org.logicmachine.rebl.common.Constants: Holds a colon character.
COLON_SPACE - Static variable in class org.logicmachine.rebl.common.Constants: Holds a colon followed by a single space character.
COMMA_SPACE - Static variable in class org.logicmachine.rebl.common.Constants: Holds a comma followed by a single space character.
command() - Method in class org.logicmachine.rebl.domain.transactions.attributes.TransactionDetails: Returns the previously defined command to be passed down to the underlying transaction resource.
COMMAND - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the label used within toString() methods to log the command associated with a transaction.
commit() - Method in class org.logicmachine.rebl.domain.transactions.managers.AbstractTransactionAwareScope
commit() - Method in class org.logicmachine.rebl.domain.transactions.managers.JdbcTransactionAwareScope.PseudoTransaction
commit() - Method in class org.logicmachine.rebl.domain.transactions.ScopedTransaction
commit(byte[]) - Method in class org.logicmachine.rebl.domain.transactions.resources.TransactionResource: Attempts to commit all work on the global transaction specified by 'globalXid'.
commit(Xid) - Method in class org.logicmachine.rebl.domain.transactions.resources.TransactionResource: Attempts to commit all work on the given transaction.
commit(Xid, boolean) - Method in class org.logicmachine.rebl.domain.transactions.resources.impl.InMemoryXAResource: Attempts to commit the specified transaction.
commitCurrentTransaction() - Method in class org.logicmachine.rebl.domain.transactions.managers.AbstractTransactionAwareScope: Attempts to commit the top-most transaction on the transaction stack.
commitCurrentTransaction() - Method in class org.logicmachine.rebl.domain.transactions.managers.TransactionAwareWithWriteAheadScope
commitTransaction() - Method in class org.logicmachine.rebl.domain.transactions.managers.AbstractTransactionAwareScope: Attempts to commit the top-most transaction on the transaction stack.
Common - Class in org.logicmachine.rebl.common: This class holds all of the common functionality required by the other Business Language classes.
compare(T, T) - Method in class org.logicmachine.rebl.domain.stateMachines.StateMachine.OrdinalComparator
COMPLETE_SUCCESS - Enum constant in enum class org.logicmachine.rebl.domain.entities.ResponseCode: Signifies that the operation completed successfully.
COMPONENT_PACKAGE_NAMES - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the name used as a label for the component package names referenced within a given scope.
componentPackageNames - Variable in class org.logicmachine.rebl.language.context.Scope: Holds the optional set of package names which will be searched to locate externally defined component classes to be invoked via the 'call()' methods.
configureInheritableScopeAssignables() - Method in class org.logicmachine.rebl.language.context.Scope: This method will configure the ScopeAssignables associated with this scope instance to be inheritable by child scopes, as appropriate.
CONNECTION_FAILED - Enum constant in enum class org.logicmachine.rebl.monitor.health.HealthStatus: Indicates that the connection to some underlying entity has failed.
ConnectionPool - Class in org.logicmachine.rebl.domain.resources.support: This class maintains a pool of database connections.
ConnectionPool() - Constructor for class org.logicmachine.rebl.domain.resources.support.ConnectionPool: Default constructor, creating a dynamically-sized pool.
ConnectionPool(String, Properties) - Constructor for class org.logicmachine.rebl.domain.resources.support.ConnectionPool: Constructor creating a a dynamically-sized pool of database connections.
Constants - Class in org.logicmachine.rebl.common: This class holds all of the required constants used within the remainder of the Business Language code-base.
contains(String, String) - Static method in class org.logicmachine.rebl.domain.exceptions.ExceptionMatcher: Helper method, returning true if:

both parameters are null 'message' is null, regardless of 'source' 'source' contains 'message'

Returns false otherwise.
CREATE - Enum constant in enum class org.logicmachine.rebl.domain.transactions.attributes.TransactionOperation: Identifies this transaction as a Create operation.
createConnectionString(SupportedDatabases, String, int, String) - Method in class org.logicmachine.rebl.domain.transactions.managers.JdbcTransactionAwareScope: Builds the full database connection string required to create a connection to the underlying database instance.
createNewConnectionPool() - Method in class org.logicmachine.rebl.domain.transactions.managers.JdbcTransactionAwareScope: Adds a new connection pool to the map for this base scope.
createNewEntry() - Method in class org.logicmachine.rebl.common.Pool: This method will construct and return a new resource entry.
createNewEntry() - Method in class org.logicmachine.rebl.domain.resources.support.ConnectionPool
createNewNameSpace() - Method in class org.logicmachine.rebl.domain.entities.ActiveEntity: Prepares this ActiveEntity instance to receive a new set of Actions which will be stored within a new namespace.
CURRENCY_FORMAT_PREFIX - Static variable in class org.logicmachine.rebl.common.Constants: Holds the logging format prefix string used to log currency values.
CURRENCY_FORMAT_SUFFIX - Static variable in class org.logicmachine.rebl.common.Constants: Holds the logging format suffix string used to log currency values.
currencyToLocaleString(Number) - Static method in class org.logicmachine.rebl.common.Common: This method will format the given currency amount into a String containing the ISO currency symbol and locale-specific currency formatting.
currentlyInUse() - Method in class org.logicmachine.rebl.common.Pool: Returns the number of pool entries currently in use (ie currently allocated).
currentSize() - Method in class org.logicmachine.rebl.common.Pool: This method returns the actual number of items currently held within the pool.
currentState() - Method in class org.logicmachine.rebl.domain.stateMachines.StateMachine: Returns the current state of this state machine.
currentState(String) - Method in class org.logicmachine.rebl.domain.stateMachines.StateMachines: Returns the current state of the specified state machine, or null if the specified state machine does not exist.
currentTransaction - Variable in class org.logicmachine.rebl.domain.transactions.managers.AbstractTransactionAwareScope: Handle to the transaction which is currently in-force.

D

DATABASE_CONNECTION_INVALID - Static variable in class org.logicmachine.rebl.common.i18n.ErrorMessages: Holds the error message generated if an attempt is made to perform a database interaction via an invalid connection.
DATABASE_CONNECTION_STRING - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the name used as a label when displaying the connection string used to connect to an underlying database.
DATABASE_EMPTY_SQL_STATEMENT - Static variable in class org.logicmachine.rebl.common.i18n.ErrorMessages: Holds the error message generated if an attempt is made to perform a database interaction with an empty SQL statement.
DATABASE_HOSTNAME_KEY - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: For JdbcTransactionAwareScopes, this value holds the property key whose corresponding value defines the hostname of the database server.
DATABASE_NAME_KEY - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: For JdbcTransactionAwareScopes, this value holds the property key whose corresponding value defines the name of the database to connect to.
DATABASE_NAME_SEPARATOR - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: For JdbcTransactionAwareScopes, this value holds the property key whose corresponding value defines the character used to separate the name of the database within the connection string.
DATABASE_NO_CONNECTION - Static variable in class org.logicmachine.rebl.common.i18n.ErrorMessages: Holds the error message generated if an attempt is made to perform a database interaction via a null connection.
DATABASE_PORT_KEY - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: For JdbcTransactionAwareScopes, this value holds the property key whose corresponding value defines the port of the database server.
DATABASE_PW_KEY - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: For JdbcTransactionAwareScopes, this value holds the property key whose corresponding value defines the passwprd to be used to establish a connection to the underlying database.
DATABASE_TYPE_KEY - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: For JdbcTransactionAwareScopes, this value holds the property key whose corresponding value defines the nature of the underlying database (eg MariaDB etc).
DATABASE_USERNAME_KEY - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: For JdbcTransactionAwareScopes, this value holds the property key whose corresponding value defines the username to be used to establish a connection to the underlying database.
databaseNameSeparatorCharacterSequence - Variable in class org.logicmachine.rebl.domain.transactions.managers.JdbcTransactionAwareScope: Holds the character sequence which separates the database name from the rest of the JDBC URI connection string.
dataStore - Variable in class org.logicmachine.rebl.domain.transactions.resources.impl.InMemoryXAResource: This is the in-memory backing store used to hold transactional values.
DATE_FORMAT - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the format string used to format date strings based on the corresponding locale-specific entry.
dateToLocaleString(Date) - Static method in class org.logicmachine.rebl.common.Common: Converts the given 'date' to a locale-specific string.
debugAnnounce() - Method in class org.logicmachine.rebl.domain.stateMachines.StateMachine: Aids debugging by announcing state changes to the standard output stream.
DEFAULT_CHARACTER_ENCODING - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Defines the default character encoding in use.
DEFAULT_CHARSET - Static variable in class org.logicmachine.rebl.common.Constants: Holds the name of the default platform character set mapping.
DEFAULT_DATABASE_PORT - Static variable in class org.logicmachine.rebl.common.Constants: For JdbcTransactionAwareScopes, this value maps to the default port of the underlying database.
DEFAULT_EXCEPTION_HANDLER - Static variable in class org.logicmachine.rebl.common.i18n.ErrorMessages: Holds the key used to name the default exception handler.
DEFAULT_EXCEPTION_HANDLER_MESSAGE_PREFIX - Static variable in class org.logicmachine.rebl.common.i18n.ErrorMessages: Holds the message prefix string which will be prepended to any error message logged by the default system exception handler.
DEFAULT_INITIAL_POOL_SIZE - Static variable in class org.logicmachine.rebl.common.Constants: Holds the default initial pool size, which will be used unless an alternative size is specified at the point of pool creation.
DEFAULT_MAX_POOL_SIZE - Static variable in class org.logicmachine.rebl.common.Pool: There is an optional upper limit on the pool size beyond which the pool will be unable to grow.
DEFAULT_POOL_INCREMENT_SIZE - Static variable in class org.logicmachine.rebl.common.Constants: Holds the number of entries which will be added to the pool each time it is necessary to grow the pool.
DEFAULT_POOL_SCALING_FACTOR - Static variable in class org.logicmachine.rebl.common.Constants: This offers an alternative way of specifying the pool growth increment by specify a scaling factor (ie a percentage of the existing size).
DEFAULT_SCOPE_NAME - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the name used as a label for the top-most default scope instance.
DEFAULT_THREAD_STARTUP_SLEEP_TIME - Static variable in class org.logicmachine.rebl.common.Constants: This is used within the 'waitForCompletion()' method.
DEFAULT_TRANSACTION_TIMEOUT_IN_SECONDS - Static variable in class org.logicmachine.rebl.common.Constants: Defines the default timeout period associated with any transaction, which will be used if no explicit timeout period is specified.
defaultExceptionState - Variable in class org.logicmachine.rebl.domain.stateMachines.StateMachineExceptionHandler: When an exception is triggered, the 'exceptionMap' is consulted to determine the corresponding state transition.
DELETE - Enum constant in enum class org.logicmachine.rebl.domain.transactions.attributes.TransactionOperation: Identifies this transaction as a Delete operation.
DELETE_FROM - Static variable in class org.logicmachine.rebl.common.Constants: Holds the SQL delete instruction.
delistAllResources(int) - Method in class org.logicmachine.rebl.domain.transactions.ScopedTransaction: Disassociates all of the resources known to the current scope from this transaction.
delistResource(XAResource, int) - Method in class org.logicmachine.rebl.domain.transactions.managers.JdbcTransactionAwareScope.PseudoTransaction: Not supported by this implementation.
delistResource(XAResource, int) - Method in class org.logicmachine.rebl.domain.transactions.ScopedTransaction
delistResource(TransactionResource, int) - Method in class org.logicmachine.rebl.domain.transactions.ScopedTransaction: Disassociates the specified 'resource' from this transaction.
DO_NOT_CREATE_POOL - Static variable in class org.logicmachine.rebl.common.Pool: Flag indicating that this pool should use lazy initialisation, to delay population of the pool until first use.
doAction() - Method in class org.logicmachine.rebl.domain.actions.Action: This is the generic entry-point to the Action sub-class, invoking the functionality associated with this Action.
doAction() - Method in class org.logicmachine.rebl.domain.actions.Action.EmptyAction
doAction() - Method in class org.logicmachine.rebl.domain.actions.Callable
doAction() - Method in class org.logicmachine.rebl.domain.actions.FlagExceptionHandledAction
doAction() - Method in class org.logicmachine.rebl.domain.actions.LogExceptionAction
doAction() - Method in class org.logicmachine.rebl.domain.actions.ObservableAction
doAction() - Method in class org.logicmachine.rebl.domain.actions.StateTransitionAction
doAction() - Method in class org.logicmachine.rebl.domain.transactions.attributes.impl.TransactionActionImpl
doAction(TransactionDetails) - Method in class org.logicmachine.rebl.domain.transactions.attributes.impl.TransactionActionImpl
doAction(TransactionDetails) - Method in interface org.logicmachine.rebl.domain.transactions.attributes.TransactionAction: Invokes an action within a transaction based on the supplied 'details'.
doAction(TransactionDetails) - Method in class org.logicmachine.rebl.domain.transactions.resources.impl.InMemoryXAResource: Allows the CRUD operation defined within the given transaction details to be added to the in-flight transaction.
doAction(TransactionDetails) - Method in class org.logicmachine.rebl.domain.transactions.resources.TransactionResource: Adds the given operation details to this resource within the context of the current transaction.
done() - Method in class org.logicmachine.rebl.domain.entities.Entity: Returns a handle to the current scope.
DOUBLE_QUOTE - Static variable in class org.logicmachine.rebl.common.Constants: Holds a double-quote character.
down() - Static method in class org.logicmachine.rebl.monitor.health.Health: Convenience method which can be used to create a health status of 'DOWN'.
DOWN - Enum constant in enum class org.logicmachine.rebl.monitor.health.HealthStatus: Indicates that some underlying entity is currently down.
DUPLICATE_SCOPE_NAME - Static variable in class org.logicmachine.rebl.common.i18n.ErrorMessages: Holds the error message used if an attempt is made to define multiple scopes with an existing name.
DurationMonitor - Class in org.logicmachine.rebl.monitor.impl: This class provides a monitor which can be used to time the duration of an activity.
DurationMonitor() - Constructor for class org.logicmachine.rebl.monitor.impl.DurationMonitor: Default constructor.
DurationMonitor(String) - Constructor for class org.logicmachine.rebl.monitor.impl.DurationMonitor: Constructor creating a new instance associated with the given 'key'.

E

empty() - Method in class org.logicmachine.rebl.common.KeyValue
empty() - Method in interface org.logicmachine.rebl.common.Maybe: Returns an empty instance of the implementing class.
empty() - Method in class org.logicmachine.rebl.domain.actors.Actor
empty() - Method in class org.logicmachine.rebl.domain.entities.ActiveEntity
empty() - Method in class org.logicmachine.rebl.domain.entities.Entity
empty() - Method in class org.logicmachine.rebl.domain.resources.Resource
empty() - Method in class org.logicmachine.rebl.domain.stateMachines.StateMachine
empty() - Method in class org.logicmachine.rebl.language.context.EnvironmentObject
EMPTY_ACTIVE_ENTITY - Static variable in class org.logicmachine.rebl.language.context.Scope: Used as a placeholder when an active entity would otherwise be null.
EMPTY_SCOPE_NAME - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the name used to represent an empty scope.
EMPTY_STRING - Static variable in class org.logicmachine.rebl.common.Constants: Holds an empty but non-null string.
emptyAction() - Static method in class org.logicmachine.rebl.domain.actions.Action: Returns a non-null no-op Action instance, which does nothing.
EmptyAction() - Constructor for class org.logicmachine.rebl.domain.actions.Action.EmptyAction
emptyActions() - Static method in class org.logicmachine.rebl.domain.actions.Actions: Returns a non-null Actions instance holding a single non-null no-op Action instance, which does nothing.
emptyActiveEntity() - Static method in class org.logicmachine.rebl.domain.entities.ActiveEntity: Returns a non-null empty ActiveEntity instance.
emptyActor() - Static method in class org.logicmachine.rebl.domain.actors.Actor: Returns a non-null empty Actor instance.
emptyEntity() - Static method in class org.logicmachine.rebl.domain.entities.Entity: Returns a non-null empty Entity instance.
EmptyEnum - Enum Class in org.logicmachine.rebl.common: Defines an empty enumeration; required to allow the creation of an 'empty' non-null state machine instance.
emptyEnvironmentObject() - Static method in class org.logicmachine.rebl.language.context.EnvironmentObject: Returns a non-null empty EnvironmentObject instance.
emptyKeyValue() - Static method in class org.logicmachine.rebl.common.KeyValue: Returns a non-null empty KeyValue instance.
EmptyOrNullArgumentException - Exception Class in org.logicmachine.rebl.domain.exceptions: This class is used to raise exceptions associated with validation checks on objects being unexpectedly null or empty instances.
EmptyOrNullArgumentException() - Constructor for exception class org.logicmachine.rebl.domain.exceptions.EmptyOrNullArgumentException: Default constructor creating an instance whose 'getMessage()' and 'getLocalizedMessage()' methods will return a string holding a stack trace.
EmptyOrNullArgumentException(String) - Constructor for exception class org.logicmachine.rebl.domain.exceptions.EmptyOrNullArgumentException: Constructor, allowing an error message to be defined.
emptyResource() - Static method in class org.logicmachine.rebl.domain.resources.Resource: Returns a non-null empty Resource instance.
emptyScope() - Static method in class org.logicmachine.rebl.language.context.Scope: Returns a non-null 'empty' Scope instance.
emptyScope() - Method in class org.logicmachine.rebl.language.Language: Returns a handle to the empty scope instance.
emptyStateMachine() - Static method in class org.logicmachine.rebl.domain.stateMachines.StateMachine: Returns a non-null empty StateMachine instance.
end(Xid, int) - Method in class org.logicmachine.rebl.domain.transactions.resources.impl.InMemoryXAResource: Ends the specified transaction based on the given 'flags'.
endRepeatable() - Method in class org.logicmachine.rebl.domain.entities.ActiveEntity: A call to this method is used to denote the end of a repeatable set of action definitions.
endScope() - Method in class org.logicmachine.rebl.common.ScopeAssignable: Completes the current scope, returning the parent scope instance, which can be a non-null 'empty' instance.
endScope() - Method in class org.logicmachine.rebl.domain.resources.Resource
endTransaction() - Method in class org.logicmachine.rebl.domain.entities.ActiveEntity: This method forms a placeholder for any transaction finalisation activity.
endTransaction() - Method in class org.logicmachine.rebl.domain.transactions.managers.AbstractTransactionAwareScope: Attempts to commit and close this transaction.
endTransaction() - Method in class org.logicmachine.rebl.language.context.Scope: This method forms a placeholder for any transaction finalisation.
endTransaction() - Method in interface org.logicmachine.rebl.language.details.Vocabulary: This method forms a placeholder for any transaction finalisation activity.
enlistAllResources() - Method in class org.logicmachine.rebl.domain.transactions.ScopedTransaction: Associates all of the resources known to the current scope with this transaction.
enlistResource(XAResource) - Method in class org.logicmachine.rebl.domain.transactions.managers.JdbcTransactionAwareScope.PseudoTransaction: Not supported by this implementation.
enlistResource(XAResource) - Method in class org.logicmachine.rebl.domain.transactions.ScopedTransaction
enlistResource(TransactionResource) - Method in class org.logicmachine.rebl.domain.transactions.ScopedTransaction: Attempts to enlist the given Resource with the current transaction.
Entities - Class in org.logicmachine.rebl.domain.entities: Collection class holding multiple Business Entity instances.
Entities() - Constructor for class org.logicmachine.rebl.domain.entities.Entities: Default constructor.
ENTITIES - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the name used as a label for the business entities within a given scope.
entity() - Method in class org.logicmachine.rebl.domain.transactions.attributes.TransactionDetails: Returns the entity on which this operation will be performed.
Entity - Class in org.logicmachine.rebl.domain.entities: This class forms the base-class of all Entities.
Entity() - Constructor for class org.logicmachine.rebl.domain.entities.Entity: Default constructor.
Entity(Object) - Constructor for class org.logicmachine.rebl.domain.entities.Entity: Constructor creating an instance associated with the given 'key'.
ENTITY - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the name used as a label for a given entity within the business entities held within a given scope.
ENTRY_ACTIONS - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the name used as a label for the entry actions for a state within a state machine.
EnvironmentObject - Class in org.logicmachine.rebl.language.context: This is a placeholder class allowing an environment object to be defined which can then be attached to either a specific scope, or made available within the 'global' scope and hence accessible everywhere.
EnvironmentObject() - Constructor for class org.logicmachine.rebl.language.context.EnvironmentObject: Default constructor.
EnvironmentObject(Object) - Constructor for class org.logicmachine.rebl.language.context.EnvironmentObject: Constructor, creating a wrapper for the given 'object'.
EnvironmentObject(Object, Object) - Constructor for class org.logicmachine.rebl.language.context.EnvironmentObject: Constructor, creating a wrapper for the given 'object'.
environmentObjects - Variable in class org.logicmachine.rebl.language.context.Scope: Holds the optional environment variables which are only visible within the current scope.
EnvironmentObjects - Class in org.logicmachine.rebl.language.context: Collection class holding a set of Objects forming the current operating environment.
EnvironmentObjects() - Constructor for class org.logicmachine.rebl.language.context.EnvironmentObjects: Default constructor.
equals(Object) - Method in class org.logicmachine.rebl.domain.transactions.attributes.impl.XidImpl
equals(Object) - Method in class org.logicmachine.rebl.domain.transactions.managers.JdbcTransactionAwareScope
equals(Object) - Method in class org.logicmachine.rebl.domain.transactions.managers.TransactionAwareScope
equals(Object) - Method in class org.logicmachine.rebl.domain.transactions.managers.TransactionAwareWithWriteAheadScope
equals(Object) - Method in class org.logicmachine.rebl.domain.transactions.resources.impl.InMemoryXAResource
equals(Object) - Method in class org.logicmachine.rebl.domain.transactions.ScopedTransaction
equals(Object) - Method in class org.logicmachine.rebl.language.context.Scope
error(Exception) - Static method in class org.logicmachine.rebl.monitor.health.Health: Convenience method which can be used to create a health status of 'ERROR' due to the given 'reason'.
ERROR - Enum constant in enum class org.logicmachine.rebl.monitor.health.HealthStatus: Specifies an 'error' state.
ErrorMessages - Class in org.logicmachine.rebl.common.i18n: This class holds all of the locale-specific externally visible error messages.
exception - Variable in class org.logicmachine.rebl.domain.exceptions.ExceptionHandler: Holds the exception currently being handled by this exception handler.
EXCEPTION_HANDLERS - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the name used as a label for the ExceptionHandlers within a given scope.
exceptionClass - Variable in class org.logicmachine.rebl.domain.exceptions.ExceptionMatcher: Holds the class of exception which will be matched by this matcher.
ExceptionHandler - Class in org.logicmachine.rebl.domain.exceptions: This class forms a base-class from which all other ExceptionHandler classes are derived.
ExceptionHandler() - Constructor for class org.logicmachine.rebl.domain.exceptions.ExceptionHandler: Default constructor.
ExceptionHandler(String) - Constructor for class org.logicmachine.rebl.domain.exceptions.ExceptionHandler: Constructor, creating an ExceptionHandler which will prefix any logging with the given 'message'.
exceptionHandlers - Variable in class org.logicmachine.rebl.language.context.Scope: Holds the optional exception handlers which are only visible within this scope instance.
ExceptionHandlers - Class in org.logicmachine.rebl.domain.exceptions: Collection class allowing a set of ExceptionHandler instances to be defined.
ExceptionHandlers() - Constructor for class org.logicmachine.rebl.domain.exceptions.ExceptionHandlers: Default constructor.
exceptionMap - Variable in class org.logicmachine.rebl.domain.stateMachines.StateMachineExceptionHandler: This map allows a number of different exceptions to be mapped to specific states.
ExceptionMatcher - Class in org.logicmachine.rebl.domain.exceptions: This class provides a mechanism to match exceptions against previously defined filtering criteria.
ExceptionMatcher() - Constructor for class org.logicmachine.rebl.domain.exceptions.ExceptionMatcher: Default constructor.
ExceptionMatcher(Class<? extends Exception>) - Constructor for class org.logicmachine.rebl.domain.exceptions.ExceptionMatcher: Constructor, creating an ExceptionMatcher whose filter will only match exceptions of the specified 'exceptionClass'.
ExceptionMatcher(Class<? extends Exception>, String) - Constructor for class org.logicmachine.rebl.domain.exceptions.ExceptionMatcher: Constructor, creating an ExceptionMatcher whose filter will only match exceptions of the specified 'exceptionClass'.
exceptionMatchers - Variable in class org.logicmachine.rebl.domain.exceptions.ExceptionHandler: Holds the (optional) list of filters which will be applied to any exception.
exists(byte[]) - Method in class org.logicmachine.rebl.domain.transactions.resources.TransactionResource: Returns true if the given global transaction is known to this resource; returns false otherwise.
EXIT_ACTIONS - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the name used as a label for the exit actions for a state within a state machine.
ExternalStrings - Class in org.logicmachine.rebl.common.i18n: This class holds all of the locale-specific externally visible string constants.

F

FAILED_TO_CLOSE_DB_CONNECTION - Static variable in class org.logicmachine.rebl.common.i18n.ErrorMessages: Holds the error message generated if an exception is caught when trying to close an existing database connection within the connection pool.
FAILED_TO_CREATE_NEW_DB_CONNECTION - Static variable in class org.logicmachine.rebl.common.i18n.ErrorMessages: Holds the error message generated if an exception is caught when trying to create a new database connection for the connection pool.
FAILED_TO_ROLLBACK_TRANSACTION_XID - Static variable in class org.logicmachine.rebl.common.i18n.ErrorMessages: Holds the error message used for XA branch transactions which have failed a rollback operation.
FAILED_WITH_HANDLED_EXCEPTION - Enum constant in enum class org.logicmachine.rebl.domain.entities.ResponseCode: Signifies that the operation failed due to an exception, although this exception was handled successfully and therefore should not be propagated.
FAILED_WITH_UNHANDLED_EXCEPTION - Enum constant in enum class org.logicmachine.rebl.domain.entities.ResponseCode: Signifies that the operation failed due to an unhandled exception which must be propagated.
FILE_ERROR_FOR_RESOURCE_BUNDLE - Static variable in class org.logicmachine.rebl.common.Constants: Whilst this is an error message it cannot be externalised into a resource bundle since it is used to generate an error message for an I/O exception whilst accessing a resource bundle.
FILE_ERROR_FOR_RESOURCE_BUNDLE - Static variable in class org.logicmachine.rebl.common.i18n.ErrorMessages: Holds the error message used for file I/O exceptions caught whilst accessing locale-specific resource bundles.
FINALISING - Enum constant in enum class org.logicmachine.rebl.monitor.health.HealthStatus: Indicates that some underlying resource is in the process of cleaning up, possibly prior to shutdown.
find(Object) - Method in class org.logicmachine.rebl.domain.actors.Actors: Searches this collection for an Actor whose key matches the given 'key' value.
find(Object) - Method in class org.logicmachine.rebl.domain.entities.Entities: Searches this collection for an element whose key matches the given 'key' value.
find(Object) - Method in class org.logicmachine.rebl.domain.resources.Resources: Searches this collection for an element whose key matches the given 'key' value.
find(Object) - Method in class org.logicmachine.rebl.domain.stateMachines.StateMachines: Searches this collection for an element whose key matches the given 'key' value.
find(Object) - Method in class org.logicmachine.rebl.language.context.EnvironmentObjects: Searches this collection for an element whose key matches the given 'key' value.
find(Object) - Method in class org.logicmachine.rebl.monitor.Monitors: Searches this collection for a Monitor whose key matches the given 'key' value.
find(Object, Maybe) - Method in class org.logicmachine.rebl.common.Many: Searches this collection for an element whose key matches the given 'key' value.
find(Object, Maybe) - Method in class org.logicmachine.rebl.common.Some: Searches this collection for an element whose key matches the given 'key' value.
find(Object, Maybe) - Method in class org.logicmachine.rebl.domain.actors.Actors
find(Object, Maybe) - Method in class org.logicmachine.rebl.domain.entities.Entities
find(Object, Maybe) - Method in class org.logicmachine.rebl.domain.resources.Resources
find(Object, Maybe) - Method in class org.logicmachine.rebl.domain.stateMachines.StateMachines
find(Object, Maybe) - Method in class org.logicmachine.rebl.language.context.EnvironmentObjects
find(Object, Maybe) - Method in class org.logicmachine.rebl.monitor.Monitors
find(String, T) - Method in class org.logicmachine.rebl.common.ScopeAssignable: Attempts to locate the entry within this ScopeAssignable collection matching the given 'key', returning this entry on match.
findAll(Object) - Method in class org.logicmachine.rebl.common.Many: Searches this collection for all elements whose keys match the given 'key' value.
findAll(Object) - Method in class org.logicmachine.rebl.common.Some: Searches this collection for all elements whose keys match the given 'key' value.
findEntityWithinScope(Class<? extends Entity>, Object) - Method in class org.logicmachine.rebl.language.context.Scope: Attempts to locate an object of the specified 'clazz' and with the given 'key' within the business entities associated with the current scope.
findWithinGlobalScope(Class<? extends Entity>, Object) - Method in class org.logicmachine.rebl.language.Language: Attempts to locate an object of the specified 'clazz' with the given 'key', within the global data.
FIXED_POOL - Static variable in class org.logicmachine.rebl.common.Pool: Flag indicating that this pool should use a fixed size, and therefore should not grow dynamically.
FlagExceptionHandledAction - Class in org.logicmachine.rebl.domain.actions: This class allows 'FlagExceptionHandledAction' objects to participate in the Actions which can be applied to an ActiveEntity instance.
FlagExceptionHandledAction() - Constructor for class org.logicmachine.rebl.domain.actions.FlagExceptionHandledAction: Default constructor.
FlagExceptionHandledAction(String) - Constructor for class org.logicmachine.rebl.domain.actions.FlagExceptionHandledAction: Constructor creating an instance of the given 'name'.
forExceptions(Class<? extends Exception>...) - Method in class org.logicmachine.rebl.common.Repeatable: This method will cause this Repeatable instance to only repeat its actions if the reason for the error matches one of the specified 'exceptions'.
forget(Xid) - Method in class org.logicmachine.rebl.domain.transactions.resources.impl.InMemoryXAResource: Removes all trace of the transaction associated with the failed transaction 'xid'.
forLanguage(Language) - Static method in class org.logicmachine.rebl.common.Common: Setter method allowing the governing language to be defined.
format - Variable in class org.logicmachine.rebl.domain.transactions.managers.TransactionAwareWithWriteAheadScope: Holds the format information of the current transaction.
FORMAT_FIELD_LENGTH_STRING_FIELD - Static variable in class org.logicmachine.rebl.common.Constants: Used within the toString() methods to format and align text fields by applying a given field width.
FORMAT_ID - Static variable in class org.logicmachine.rebl.domain.transactions.attributes.impl.XidImpl: Defines the identifier used to specify the nature of the transaction id.
FORWARD_SLASH - Static variable in class org.logicmachine.rebl.common.Constants: Holds the forward-slash character.
FROM - Static variable in class org.logicmachine.rebl.common.Constants: Holds the SQL 'from' clause.

G

get() - Method in class org.logicmachine.rebl.common.KeyValue
get() - Method in interface org.logicmachine.rebl.common.Maybe: Returns a handle to the underlying object if such an object exists; returns a non-null 'empty' instance otherwise.
get(Xid, Object) - Method in class org.logicmachine.rebl.domain.transactions.resources.impl.InMemoryXAResource: As part of the transaction associated with the specified 'xid', this method will return the current value of the entry identified by the given 'key'.
getActiveEntities() - Method in class org.logicmachine.rebl.domain.actors.Actor: Derived classes should override this method.
getActiveEntities() - Method in class org.logicmachine.rebl.domain.entities.OwningEntity: Returns a collection of the ActiveEntity instances 'owned' by this entity.
getActiveEntity() - Method in class org.logicmachine.rebl.domain.actors.Actor: Derived classes should override this method.
getActiveEntity() - Method in class org.logicmachine.rebl.domain.entities.OwningEntity: Returns a handle to the ActiveEntity 'owned' by this entity.
getActiveEntity() - Method in class org.logicmachine.rebl.language.context.Scope: Returns the non-null currently active entity.
getActiveResource() - Method in class org.logicmachine.rebl.language.context.Scope: Returns a handle to the currently active Resource instance.
getBranchQualifier() - Method in class org.logicmachine.rebl.domain.transactions.attributes.impl.XidImpl
getCollection() - Method in class org.logicmachine.rebl.common.Many
getCollection() - Method in class org.logicmachine.rebl.common.Some: Returns all of the objects within this collection.
getConnection() - Method in class org.logicmachine.rebl.domain.transactions.managers.JdbcTransactionAwareScope: Returns a connection to the underlying database.
getConnectionPool() - Method in class org.logicmachine.rebl.domain.transactions.managers.JdbcTransactionAwareScope: Returns a handle to the connection pool associated with this base scope.
getConnectionPoolMapName() - Method in class org.logicmachine.rebl.domain.transactions.managers.JdbcTransactionAwareScope: Returns the name of the connection pool map entry associated with this base scope.
getCurrentException() - Method in class org.logicmachine.rebl.domain.exceptions.ExceptionHandler: Returns the exception currently being handled by this exception handler.
getDefaultScopeType() - Static method in class org.logicmachine.rebl.language.context.Scope: Returns the nature of the scope which will be created by default via the 'newInstance()' method.
getEnlistedResources() - Method in class org.logicmachine.rebl.domain.transactions.ScopedTransaction: Returns a non-null list of the enlisted resources.
getEntities(Class<? extends Entity>) - Method in class org.logicmachine.rebl.language.context.Scope: Returns the entities within the current scope matching the specified 'clazz', or an empty non-null Entities instance if no such entities have been defined.
getEntry() - Method in class org.logicmachine.rebl.common.Pool: This method will return the next available resource entry from the pool, if one is currently available.
getEnvironmentObject(Object) - Method in class org.logicmachine.rebl.language.context.Scope: Returns the environment object with the given 'key' from with this scope, or an empty non-null environment object on no match.
getEnvironmentObjects() - Method in class org.logicmachine.rebl.language.context.Scope: Returns the set of environment objects associated with this scope, or an empty non-null list if no environment objects have been defined.
getExceptionMessage(Exception) - Static method in class org.logicmachine.rebl.common.Common: Returns the exception message for the given 'exception'.
getFormatId() - Method in class org.logicmachine.rebl.domain.transactions.attributes.impl.XidImpl
getGlobalEnvironmentObject(Object) - Method in class org.logicmachine.rebl.language.Language: Returns the global environment object with the given 'key', or an empty non-null environment object on no match.
getGlobalTransactionId() - Method in class org.logicmachine.rebl.domain.transactions.attributes.impl.XidImpl
getGlobalTransactionId() - Method in class org.logicmachine.rebl.domain.transactions.ScopedTransaction: Returns the unique global transaction ID with which this transaction is associated.
getHealthStatus() - Method in class org.logicmachine.rebl.monitor.health.Health: Returns the current health status of this instance.
getHostnameForConnectionString(SupportedDatabases, String) - Method in class org.logicmachine.rebl.domain.transactions.managers.JdbcTransactionAwareScope: For HSQL, this method will return the given hostname unchanged.
getLocalizedMessage() - Method in exception class org.logicmachine.rebl.domain.exceptions.EmptyOrNullArgumentException
getMaxFieldWidth() - Static method in class org.logicmachine.rebl.domain.transactions.attributes.impl.XidImpl: Returns the width of largest interal field, which is used to align the fields contributing to the 'toString()' methods within this class.
getMessage() - Method in exception class org.logicmachine.rebl.domain.exceptions.EmptyOrNullArgumentException
getMessage() - Method in class org.logicmachine.rebl.domain.exceptions.ExceptionHandler: Returns the (optional) message which has been defined for this handler.
getMessageFromResourceBundle(ResourceBundle, String) - Static method in class org.logicmachine.rebl.common.i18n.ResourceBundles: Returns the string representation of the given input parameter as read from the given resource bundle.
getName() - Method in enum class org.logicmachine.rebl.domain.transactions.attributes.SupportedDatabases: Returns the name used to construct a connection string for this database flavour.
getNextAvailable() - Method in class org.logicmachine.rebl.common.Pool: This method will return the next available entry from the current pool.
getNextParallelActiveEntity() - Method in class org.logicmachine.rebl.language.Language: Returns the next parallel active entity.
getNextParallelActiveEntity(Map<Thread, List<ActiveEntity>>) - Static method in class org.logicmachine.rebl.language.Language: Returns the next parallel active entity from any of the threads within the given 'entry' map.
getNextParallelActiveEntityForScope(Scope) - Method in class org.logicmachine.rebl.language.Language: Returns the next parallel active entity.
getNextTransactionBranchQualifier() - Static method in class org.logicmachine.rebl.domain.transactions.attributes.impl.XidImpl: Builds a new unique transaction branch qualifier based on a unique identifier, the transaction start time and an incrementing AtomicLong.
getNumberOfPendingParallelActiveEntitiesForScope(Scope) - Method in class org.logicmachine.rebl.language.Language: Returns a count of the number of parallel active entity instances associated with the given 'scope' which are currently running, pending completion.
getObjects() - Method in class org.logicmachine.rebl.common.ScopeAssignable: Returns the set of objects attached to the current scope within this ScopeAssignable, in the order of definition.
getObjectsInReverseOrder() - Method in class org.logicmachine.rebl.common.ScopeAssignable: Returns the set of objects attached to the current scope within this ScopeAssignable, in reverse order of definition.
getParallelThread() - Method in class org.logicmachine.rebl.domain.entities.ActiveEntity: For a parallel active entity instance which is currently running, this method will return the new thread responsible for running the actions in parallel.
getPreparedStatement(String) - Method in class org.logicmachine.rebl.domain.transactions.managers.JdbcTransactionAwareScope: Attempts to create a PreparedStatement from the specified 'sql'.
getPropertyChangeEvent() - Method in class org.logicmachine.rebl.common.KeyValue: Returns a default PropertyChangeEvent containing a handle to this instance as the source of the event.
getPropertyChangeEvent() - Method in class org.logicmachine.rebl.domain.stateMachines.StateMachine: Returns a PropertyChangeEvent containing a handle to this instance as the source of the event as well as a STATE property with 'previousState' and 'currentState' values.
getReason() - Method in class org.logicmachine.rebl.monitor.health.Health: Returns the (optional) reason or cause of the current health status.
getRepeatCount() - Method in class org.logicmachine.rebl.common.Repeatable: Returns the maximum number of repeat attempts permitted.
getResource() - Method in class org.logicmachine.rebl.domain.transactions.resources.TransactionResource: Returns a handle to the underlying XAResource associated with this instance.
getResourceBundle(String) - Static method in class org.logicmachine.rebl.common.i18n.ResourceBundles: This method will search the class path for the given resource bundle matching the default locale.
getResources() - Method in class org.logicmachine.rebl.language.context.Scope: Returns the set of resources associated with this scope, or an empty non-null list if no resources have been defined.
getResults() - Method in class org.logicmachine.rebl.domain.transactions.attributes.TransactionDetails: Returns any results associated with this transaction.
getResults(PreparedStatement) - Static method in class org.logicmachine.rebl.domain.transactions.managers.JdbcTransactionAwareScope: If the previously executed SQL action returned any results this method will return those results.
getScope() - Method in class org.logicmachine.rebl.domain.transactions.ScopedTransaction: Returns the TransactionAwareScope associated with this transaction.
getScopeInitialisationProperties(Class<?>, Object) - Static method in class org.logicmachine.rebl.language.context.Scope: This method returns a cloned copy of any scope-class and/or scope-specific initialisation properties previously defined for the specified 'scopeClass' or 'key'.
getScopePropertiesAndConnectionString() - Method in class org.logicmachine.rebl.domain.transactions.managers.JdbcTransactionAwareScope: Builds the properties and connection string required to create connections to the underlying database instance.
getScopes() - Method in class org.logicmachine.rebl.domain.resources.Resource: Returns a list of scopes to which this resource has been attached.
getSingleResult(PreparedStatement) - Static method in class org.logicmachine.rebl.domain.transactions.managers.JdbcTransactionAwareScope: If invoking this Action returned a single row containing a single value, then this method will return that value; otherwise this method returns null.
getStatus() - Method in class org.logicmachine.rebl.domain.transactions.managers.AbstractTransactionAwareScope
getStatus() - Method in class org.logicmachine.rebl.domain.transactions.managers.JdbcTransactionAwareScope.PseudoTransaction
getStatus() - Method in class org.logicmachine.rebl.domain.transactions.ScopedTransaction: See also the 'getTransactionStatus()' method, which returns the enumerated value corresponding to the current transaction status.
getStatusFlags(Xid) - Method in class org.logicmachine.rebl.domain.transactions.resources.impl.InMemoryXAResource: Returns the flags associated with the given transaction.
getTransaction() - Method in class org.logicmachine.rebl.domain.transactions.managers.AbstractTransactionAwareScope
getTransactionId() - Method in class org.logicmachine.rebl.domain.transactions.ScopedTransaction: Returns the unique transaction ID which was assigned to this instance by the transaction manager.
getTransactionManager() - Method in class org.logicmachine.rebl.domain.transactions.ScopedTransaction: Returns the TransactionManager associated with this transaction.
getTransactionStatus() - Method in class org.logicmachine.rebl.domain.transactions.managers.AbstractTransactionAwareScope: Returns the status of the current transaction running within this scope.
getTransactionStatus() - Method in class org.logicmachine.rebl.domain.transactions.managers.JdbcTransactionAwareScope: Not supported by this implementation.
getTransactionStatus() - Method in class org.logicmachine.rebl.domain.transactions.managers.TransactionAwareScope: Returns the status of the current transaction running within this scope.
getTransactionStatus() - Method in class org.logicmachine.rebl.domain.transactions.ScopedTransaction: Returns the current status of this transaction.
getTransactionTimeout() - Method in class org.logicmachine.rebl.domain.transactions.resources.impl.InMemoryXAResource: Returns the current transaction timeout, or zero if not explicitly defined.
getTransactionTimeout() - Method in class org.logicmachine.rebl.domain.transactions.ScopedTransaction: Returns the current transaction timeout period for this transaction.
getType() - Method in class org.logicmachine.rebl.domain.entities.Entities: Provides the ability to determine the class type of the entities held within this collection.
getType() - Method in class org.logicmachine.rebl.domain.entities.Entity: Returns the sub-class to which this derived instance belongs.
getXid() - Method in class org.logicmachine.rebl.domain.transactions.attributes.TransactionDetails: Returns the transaction identifier which uniquely identifies this transaction.
giveNextAvailable() - Method in class org.logicmachine.rebl.common.Pool: Returns the next available resource instance, updating the internal pool and associated counters.
global - Variable in class org.logicmachine.rebl.domain.transactions.managers.TransactionAwareWithWriteAheadScope: Holds the global transaction id of the current transaction.
GLOBAL_DATA - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the name used as a label for the global scope data, which represents the global data accessible from any scope.
GLOBAL_ENVIRONMENT - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the name used as a label for the global environment data, which represents the global environment data accessible from any scope.
Grammar - Class in org.logicmachine.rebl.language.details: This is a placeholder class defining the specific grammar constructs supported by the language.
Grammar() - Constructor for class org.logicmachine.rebl.language.details.Grammar: Default constructor.

H

handleException(Exception) - Method in class org.logicmachine.rebl.domain.exceptions.ExceptionHandler: Derived classes can override this method, which deals with system (ie non-business) exceptions only.
handleException(Exception) - Method in class org.logicmachine.rebl.domain.stateMachines.StateMachineExceptionHandler: This method will log the given 'exception' to the standard error stream and then trigger a state transition within the underlying state machine.
handleException(Exception) - Method in class org.logicmachine.rebl.language.context.Scope: This method will iterate over the set of ExceptionHandlers (if any) attached to the current scope.
handleException(BusinessMessage) - Method in class org.logicmachine.rebl.domain.exceptions.ExceptionHandler: Derived classes can override this method, which deals with business exceptions only.
handleException(BusinessMessage) - Method in class org.logicmachine.rebl.domain.stateMachines.StateMachineExceptionHandler: This method will log the given 'businessMessage' to the standard error stream and then trigger a state transition within the underlying state machine.
HAS_XA_RESOURCE_ERROR - Static variable in class org.logicmachine.rebl.common.i18n.ErrorMessages: Holds the error message used if an attempt is made to associate a TransactionResource with more than one XA Resource.
hasArguments() - Method in class org.logicmachine.rebl.domain.actions.Callable: Returns true if arguments have previously been defined for this Callable.
hashCode() - Method in class org.logicmachine.rebl.domain.transactions.attributes.impl.XidImpl
hashCode() - Method in class org.logicmachine.rebl.domain.transactions.managers.JdbcTransactionAwareScope
hashCode() - Method in class org.logicmachine.rebl.domain.transactions.managers.TransactionAwareScope
hashCode() - Method in class org.logicmachine.rebl.domain.transactions.managers.TransactionAwareWithWriteAheadScope
hashCode() - Method in class org.logicmachine.rebl.domain.transactions.resources.impl.InMemoryXAResource
hashCode() - Method in class org.logicmachine.rebl.domain.transactions.ScopedTransaction
hashCode() - Method in class org.logicmachine.rebl.language.context.Scope
hasObjects() - Method in class org.logicmachine.rebl.common.ScopeAssignable: Returns true if there are objects attached to the current scope within this ScopeAssignable; false otherwise.
hasPendingParallelActiveEntities(Scope) - Static method in class org.logicmachine.rebl.common.Common: Returns true if the given 'scope' has parallel active entity instances currently running, pending completion.
hasScopes() - Method in class org.logicmachine.rebl.domain.resources.Resource: Returns true if this resource is still associated with one or more scope instances.
Health - Class in org.logicmachine.rebl.monitor.health: This class denotes the overall health of an entity.
Health() - Constructor for class org.logicmachine.rebl.monitor.health.Health
HealthMonitor - Class in org.logicmachine.rebl.monitor.impl: This class provides a monitor which can be used to monitor the health of a resource.
HealthMonitor() - Constructor for class org.logicmachine.rebl.monitor.impl.HealthMonitor: Default constructor.
HealthMonitor(String) - Constructor for class org.logicmachine.rebl.monitor.impl.HealthMonitor: Constructor creating a new instance associated with the given 'key'.
HealthStatus - Enum Class in org.logicmachine.rebl.monitor.health: This enumeration defines the health of a given entity.
HEX_VALUES - Static variable in class org.logicmachine.rebl.common.Constants: Holds the hexadecimal values which are used to convert byte arrays to hexadecimal strings.
HSQL - Enum constant in enum class org.logicmachine.rebl.domain.transactions.attributes.SupportedDatabases: Specifies that the underlying database in use is HSQL.

I

idle() - Static method in class org.logicmachine.rebl.monitor.health.Health: Convenience method which can be used to create a health status of 'IDLE'.
IDLE - Enum constant in enum class org.logicmachine.rebl.monitor.health.HealthStatus: Indicates that some underlying entity is up and running but is currently doing no useful work.
indent(int) - Static method in class org.logicmachine.rebl.common.Common: Returns a space-filled string representing the padding required to provide indentation to the required level.
INDENT - Static variable in class org.logicmachine.rebl.common.Constants: Holds 4 spaces, providing one level of indentation within the 'toString()' methods.
INDENT_SIZE - Static variable in class org.logicmachine.rebl.common.Constants: Used to align the fields contributing to the 'toString()' methods.
indentAndAlign(int, String, int) - Static method in class org.logicmachine.rebl.common.Common: Returns a string containing indentation to the specified level followed by the given value, formatted to the specified width.
INFO - Enum constant in enum class org.logicmachine.rebl.monitor.health.HealthStatus: Specifies an 'information' state.
inheritBusinessEntities - Variable in class org.logicmachine.rebl.language.context.Scope: Flag specifying if the 'businessEntities' associated with this instance are inheritable by child scopes.
inheritParallelSetting - Variable in class org.logicmachine.rebl.language.context.Scope: Flag specifying if child scopes of this parent scope should inherit the 'parallel' setting of this parent.
inheritParallelSetting() - Method in class org.logicmachine.rebl.language.context.Scope: By default, a child scope does NOT inherit the parallel setting of its parent.
inheritScopeAssignables(Scope) - Method in class org.logicmachine.rebl.language.context.Scope: Applies those ScopeAssignables configured as inheritable from the current (parent) scope, to the given 'childScope'.
initialise(boolean, int, int, int, boolean) - Method in class org.logicmachine.rebl.common.Pool: This method actually creates the pool structure.
initialiseNewTransactionLog() - Method in class org.logicmachine.rebl.domain.transactions.managers.TransactionAwareWithWriteAheadScope: Attempts to create a new transaction log file based on the name associated with this scope.
INITIALISING - Enum constant in enum class org.logicmachine.rebl.monitor.health.HealthStatus: Indicates that some underlying resource is in the process of initialising itself during start-up.
InMemoryXAResource - Class in org.logicmachine.rebl.domain.transactions.resources.impl: This class represents a simple implementation of the XAResource interface.
InMemoryXAResource() - Constructor for class org.logicmachine.rebl.domain.transactions.resources.impl.InMemoryXAResource: Default constructor.
InMemoryXAResource(int) - Constructor for class org.logicmachine.rebl.domain.transactions.resources.impl.InMemoryXAResource: Constructor creating a new instance identified by the given 'resourceId'.
INSERT_INTO - Static variable in class org.logicmachine.rebl.common.Constants: Holds the SQL insert instruction.
inUse - Variable in class org.logicmachine.rebl.common.Pool: The list of allocated (in-use) pool entries.
INVALID_ACTION - Static variable in class org.logicmachine.rebl.common.i18n.ErrorMessages: Holds the error message used for invalid Action definitions within a state machine.
INVALID_SCOPE - Static variable in class org.logicmachine.rebl.common.i18n.ErrorMessages: Holds the initial error message prefix used for user-defined Scope sub-classes which have not defined the required constructor.
INVALID_SCOPE_CONSTRUCTOR - Static variable in class org.logicmachine.rebl.common.i18n.ErrorMessages: Holds the parameter details of the missing constructor for user-defined Scope sub-classes which have invalid definitions.
INVALID_SCOPE_REASON - Static variable in class org.logicmachine.rebl.common.i18n.ErrorMessages: Holds the error message reason for user-defined Scope sub-classes which have not defined the required constructor.
INVALID_STATE - Static variable in class org.logicmachine.rebl.common.i18n.ErrorMessages: Holds the error message used for invalid state transition definitions within a state machine.
INVALID_STATE_TRANSITION - Static variable in class org.logicmachine.rebl.common.i18n.ErrorMessages: State Machines are referenced by name.
invokeCallableInScope(Scope) - Method in class org.logicmachine.rebl.domain.actions.Callable: This method can be used to directly invoke this callable.
IS_EMPTY_WITH_LEADING_SPACE - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the prefix used within 'toString()' methods to indicate that a KeyValue instance is 'empty'.
IS_TOP_MOST_GLOBAL_TRANSACTION - Static variable in class org.logicmachine.rebl.domain.transactions.managers.AbstractTransactionAwareScope: Used to set a flag indicating that this instance represents a top-level global transaction.
isClosed - Variable in class org.logicmachine.rebl.domain.resources.CloseableResource: This flag is set to true once the resource has been closed.
isClosed - Variable in class org.logicmachine.rebl.language.context.Scope: This flag will be automatically set to true once this scope has been closed.
isClosed() - Method in class org.logicmachine.rebl.language.context.Scope: Returns true once this scope has been closed.
isDefaultScope() - Method in class org.logicmachine.rebl.language.context.Scope: Returns true if this scope is the default (top-most) scope.
isEmpty() - Method in class org.logicmachine.rebl.common.KeyValue
isEmpty() - Method in interface org.logicmachine.rebl.common.Maybe: Returns true if the underlying object represents an empty instance; returns false if the underlying object is a fully operational instance.
isEmpty(String) - Static method in class org.logicmachine.rebl.common.Common: Returns true if 'value' is null or empty; false otherwise.
isGlobalTransaction() - Method in class org.logicmachine.rebl.domain.transactions.ScopedTransaction: Returns true if this transaction is a topmost global transaction, false if this represents an inner local transaction.
isHandled() - Method in exception class org.logicmachine.rebl.domain.exceptions.BusinessMessage: Returns true if this exception has been successfully handled by an exception handler.
isInheritable() - Method in class org.logicmachine.rebl.common.ScopeAssignable: Returns true if this ScopeAssignable instance should be inherited by child scopes from a parent scope.
isInheritable(boolean) - Method in class org.logicmachine.rebl.common.ScopeAssignable: If 'inherit' is true, this ScopeAssignable will be inheritable by child scopes of a parent scope.
isInState(String, Enum<?>) - Method in class org.logicmachine.rebl.domain.stateMachines.StateMachines: Returns true if the specified state machine is currently in the given state; false otherwise (or if the specified state machine does not exist).
isInState(T) - Method in class org.logicmachine.rebl.domain.stateMachines.StateMachine: Returns true if the state machine is currently in the specified state.
isMultiLine(String) - Static method in class org.logicmachine.rebl.common.Common: Returns true if the given 'value' consists of a multi-line string.
isParallel() - Method in class org.logicmachine.rebl.domain.entities.ActiveEntity: Returns true if this instance has been flagged as a parallel ActiveEntity by either calling the 'parallel()' method or by associating this instance with a parallel scope.
isParallel() - Method in class org.logicmachine.rebl.language.context.Scope: Returns true if this instance should invoke its defined actions in parallel.
isParallelThreadComplete() - Method in class org.logicmachine.rebl.domain.entities.ActiveEntity: Returns true if this active entity is parallel and the parallel thread has completed.
isSameGlobalTransaction(ScopedTransaction) - Method in class org.logicmachine.rebl.domain.transactions.ScopedTransaction: Returns true if this instance and the 'other' transaction are both part of the same global transaction.
isSameGlobalTransactionId(Xid) - Method in class org.logicmachine.rebl.domain.transactions.attributes.impl.XidImpl: Returns true if this instance and the 'other' transaction are both part of the same global transaction.
isSameResource(XAResource) - Method in class org.logicmachine.rebl.domain.transactions.resources.TransactionResource: Returns true if the given XAResource matches the XAResource wrapped by this instance.
isSameResource(TransactionResource) - Method in class org.logicmachine.rebl.domain.transactions.resources.TransactionResource: Returns true if the XAResource wrapped by the specified 'other' resource matches the resource wrapped by this instance.
isSameRM(XAResource) - Method in class org.logicmachine.rebl.domain.transactions.resources.impl.InMemoryXAResource: Returns true if the given 'other' resource represents the same resource manager as the current instance.
isSameRM(TransactionResource) - Method in class org.logicmachine.rebl.domain.transactions.resources.TransactionResource: Returns true if the resource manager of the specified 'other' resource matches that of this instance.
isTopLevel - Variable in class org.logicmachine.rebl.domain.transactions.managers.TransactionAwareWithWriteAheadScope: Set to true if the current transaction is a top-level transaction; false if it is an inner transaction.
isValidConnection() - Method in class org.logicmachine.rebl.domain.transactions.managers.JdbcTransactionAwareScope: Issues a verification request to the underlying database to positively verify if the connection is still valid.
iterator() - Method in class org.logicmachine.rebl.common.Many
iterator() - Method in class org.logicmachine.rebl.common.SafeIterable: Returns either an iterator for the underlying Collection, or the Collections.emptyList().iterator() if the underlying Collection is null.
iterator() - Method in class org.logicmachine.rebl.common.Some

J

JDBC_CONNECTION_STRING_PREFIX - Static variable in class org.logicmachine.rebl.common.Constants: URI prefix for JDBC connection strings.
JdbcTransactionAwareScope - Class in org.logicmachine.rebl.domain.transactions.managers: Nested scopes provide isolation for blocks of business logic.
JdbcTransactionAwareScope(String) - Constructor for class org.logicmachine.rebl.domain.transactions.managers.JdbcTransactionAwareScope: Constructor creating a new scope instance of the given 'scopeName', with the range of configuration values being read from the 'scopeInitialisationProperties'.
JdbcTransactionAwareScope(String, boolean) - Constructor for class org.logicmachine.rebl.domain.transactions.managers.JdbcTransactionAwareScope: Constructor creating a new scope instance of the given 'scopeName', with the range of configuration values being read from the 'scopeInitialisationProperties'.
JdbcTransactionAwareScope.PseudoTransaction - Class in org.logicmachine.rebl.domain.transactions.managers: This class represents one transaction associated with a specific database connection.

K

key() - Method in class org.logicmachine.rebl.common.KeyValue: Returns the key associated with this instance.
KeyValue - Class in org.logicmachine.rebl.common: This helper class denotes support for an element which can be referenced by a 'key' value.
KeyValue() - Constructor for class org.logicmachine.rebl.common.KeyValue: Default constructor.
KeyValue(Object) - Constructor for class org.logicmachine.rebl.common.KeyValue: Constructor allowing the given 'key' to be defined for this instance.

L

language() - Method in class org.logicmachine.rebl.common.LanguageAssignable: Returns the language associated with this instance.
Language - Class in org.logicmachine.rebl.language: Top-level class defining the entry-point into the language.
Language(String) - Constructor for class org.logicmachine.rebl.language.Language: Constructor, creating a new language instance of the given 'languageName'.
Language(String, Class<? extends Scope>) - Constructor for class org.logicmachine.rebl.language.Language: Constructor, creating a new language instance of the given 'languageName'.
LanguageAssignable<T> - Class in org.logicmachine.rebl.common: This helper class denotes support for an element which can reference its enclosing Language instance.
LanguageAssignable() - Constructor for class org.logicmachine.rebl.common.LanguageAssignable: Default constructor.
largestStringLength(String...) - Static method in class org.logicmachine.rebl.common.Common: Returns the length of the largest (trimmed) string in 'values'.
LITERAL_VALUES - Static variable in class org.logicmachine.rebl.common.Constants: Holds the SQL 'values' keyword for insert instructions.
LOCAL_HOST - Static variable in class org.logicmachine.rebl.common.Constants: Holds the hostname for the local machine.
log() - Method in interface org.logicmachine.rebl.common.Loggable: This method provides logging functionality.
log() - Method in class org.logicmachine.rebl.domain.entities.Entity
log(String) - Static method in class org.logicmachine.rebl.common.Common: Logs the given text to the standard output stream.
log(String) - Method in class org.logicmachine.rebl.language.context.Scope: Logs the given text to the standard output stream.
logException(Exception) - Static method in class org.logicmachine.rebl.common.Common: Logs the given 'exception'.
logException(String, Exception) - Static method in class org.logicmachine.rebl.common.Common: Logs the given 'exception', prepending the (optional) 'message' text.
logException(String, BusinessMessage) - Static method in class org.logicmachine.rebl.common.Common: Logs the given 'businessMessage', prepending the (optional) 'message' text.
LogExceptionAction - Class in org.logicmachine.rebl.domain.actions: This class allows 'LoggableAction' objects to participate in the Actions which can be applied to an ActiveEntity instance.
LogExceptionAction() - Constructor for class org.logicmachine.rebl.domain.actions.LogExceptionAction: Default constructor.
LogExceptionAction(String) - Constructor for class org.logicmachine.rebl.domain.actions.LogExceptionAction: Constructor creating a LoggableAction instance of the given 'name'.
Loggable - Interface in org.logicmachine.rebl.common: Small helper interface denoting an element which supports logging.
logWithLeadingNewline(String) - Method in class org.logicmachine.rebl.language.context.Scope: Logs a leading newline followed by the given message.
logWithTrailingNewline(String) - Method in class org.logicmachine.rebl.language.context.Scope: Logs the given message followed by a trailing newline.

M

Many<T> - Class in org.logicmachine.rebl.common: General purpose 'pluraliser' class which can be used as a base class for the creation of a collection of 'singular' objects.
Many() - Constructor for class org.logicmachine.rebl.common.Many: Default constructor.
Many(T...) - Constructor for class org.logicmachine.rebl.common.Many: Constructor allowing a number of 'singular' instances to be added to this collection class.
MARIADB - Enum constant in enum class org.logicmachine.rebl.domain.transactions.attributes.SupportedDatabases: Specifies that the underlying database in use is MariaDB.
matches(Exception) - Method in class org.logicmachine.rebl.domain.exceptions.ExceptionMatcher: Applies this matcher to the given 'exception'.
matchNone() - Static method in class org.logicmachine.rebl.domain.exceptions.ExceptionMatcher: Returns an ExceptionMatcher which will NEVER match ANY exception.
MAX_RETRIES - Enum constant in enum class org.logicmachine.rebl.monitor.health.HealthStatus: Indicates that we have retried some activity the maximum number of permitted times.
maxPoolSize - Variable in class org.logicmachine.rebl.common.Pool: Holds the optional maximum size to which this pool can grow.
Maybe - Interface in org.logicmachine.rebl.common: This interface is available throughout the fluent-interface code-base to handle those circumstances when a method could otherwise return a null value.
message - Variable in class org.logicmachine.rebl.domain.exceptions.ExceptionHandler: Holds the (optional) message to prepend to any exception logged via this instance.
message - Variable in class org.logicmachine.rebl.domain.exceptions.ExceptionMatcher: Holds the (optional) message to check for within the 'getMessage()' and/or 'getLocalizedMessage()' method results for this exception.
MISSING_JDBC_PROPERTIES - Static variable in class org.logicmachine.rebl.common.i18n.ErrorMessages: Holds the error message used to highlight missing JDBC initialisation properties for a JdbcTransactionAwareScope instance.
MISSING_PROPERTY - Static variable in class org.logicmachine.rebl.common.i18n.ErrorMessages: Holds the error message used to highlight a missing resource within a locale-specific resource bundle.
Monitor<T> - Class in org.logicmachine.rebl.monitor: This base class denotes an element which supports the addition of a monitor.
Monitor() - Constructor for class org.logicmachine.rebl.monitor.Monitor
MONITOR - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the label used within toString() methods to log the key associated with a monitor.
MONITOR_VALUE - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the label used within toString() methods to log the value associated with a monitor.
monitorAfter(boolean) - Method in class org.logicmachine.rebl.domain.entities.ActiveEntity: This hook will be invoked 'after' any actual processing takes place.
monitorAfter(boolean) - Method in class org.logicmachine.rebl.language.context.Scope: This hook will be invoked 'after' any actual processing takes place.
monitorAfter(boolean) - Method in interface org.logicmachine.rebl.language.details.Vocabulary: This hook will be invoked 'after' any actual processing takes place.
monitorAfter(boolean) - Method in class org.logicmachine.rebl.monitor.impl.DurationMonitor
monitorAfter(boolean) - Method in class org.logicmachine.rebl.monitor.impl.ThreadsafeThroughputMonitor: Not used by this implementation.
monitorAfter(boolean) - Method in class org.logicmachine.rebl.monitor.impl.ThroughputMonitor: Not used by this implementation.
monitorAfter(boolean) - Method in class org.logicmachine.rebl.monitor.Monitor: This hook will be invoked 'after' any actual processing takes place.
monitorBefore() - Method in class org.logicmachine.rebl.domain.entities.ActiveEntity: This hook will be invoked 'before' any actual processing takes place.
monitorBefore() - Method in class org.logicmachine.rebl.language.context.Scope: This hook will be invoked 'before' any actual processing takes place.
monitorBefore() - Method in interface org.logicmachine.rebl.language.details.Vocabulary: This hook will be invoked 'before' any actual processing takes place.
monitorBefore() - Method in class org.logicmachine.rebl.monitor.impl.DurationMonitor
monitorBefore() - Method in class org.logicmachine.rebl.monitor.impl.ThreadsafeThroughputMonitor
monitorBefore() - Method in class org.logicmachine.rebl.monitor.impl.ThroughputMonitor
monitorBefore() - Method in class org.logicmachine.rebl.monitor.Monitor: This hook will be invoked 'before' any actual processing takes place.
monitorGet() - Method in class org.logicmachine.rebl.monitor.impl.DurationMonitor
monitorGet() - Method in class org.logicmachine.rebl.monitor.impl.HealthMonitor
monitorGet() - Method in class org.logicmachine.rebl.monitor.impl.ThreadsafeThroughputMonitor
monitorGet() - Method in class org.logicmachine.rebl.monitor.impl.ThroughputMonitor
monitorGet() - Method in class org.logicmachine.rebl.monitor.Monitor: This method can be used to allow a monitor to pass back any calculated value(s) following execution.
monitors - Variable in class org.logicmachine.rebl.language.context.Scope: Holds the optional monitors which are used to monitor the invocation of the business functionality against the active entities.
Monitors - Class in org.logicmachine.rebl.monitor: Collection class holding a set of Monitor instances.
Monitors() - Constructor for class org.logicmachine.rebl.monitor.Monitors: Default constructor.
MYSQL - Enum constant in enum class org.logicmachine.rebl.domain.transactions.attributes.SupportedDatabases: Specifies that the underlying database in use is MySQL.

N

newInstance(Class<? extends Scope>, String) - Static method in class org.logicmachine.rebl.language.context.Scope: Factory method creating a new scope instance of the specified type and with the given 'scopeName'.
newInstance(Class<? extends Scope>, String, ActiveEntity) - Static method in class org.logicmachine.rebl.language.context.Scope: Factory method creating a new scope instance of the specified type and with the given 'scopeName'.
newInstance(String) - Static method in class org.logicmachine.rebl.language.context.Scope: Factory method creating a new scope instance of the type specified by the 'setDefaultScopeType()' method, or an instance of the base "Scope" class by default.
newInstance(String, ActiveEntity) - Static method in class org.logicmachine.rebl.language.context.Scope: Factory method creating a new scope instance of the type specified by the 'setDefaultScopeType()' method, or an instance of the base "Scope" class by default.
NEWLINE - Static variable in class org.logicmachine.rebl.common.Constants: Holds the platform-specific newline character sequence.
newParallelInstance(Class<Scope>, String) - Static method in class org.logicmachine.rebl.language.context.Scope: Convenience method which is identical to calling the 'newInstance(scopeType, scopeName)' method, or subsequently invoking the 'parallel()' method.
newParallelInstance(String) - Static method in class org.logicmachine.rebl.language.context.Scope: Convenience method which is identical to calling the 'newInstance(scopeName)' method followed by the 'parallel()' method.
newSequentialInstance(Class<Scope>, String) - Static method in class org.logicmachine.rebl.language.context.Scope: Convenience method which is identical to calling the 'newInstance(scopeType, scopeName)' method, or subsequently invoking the 'sequential()' method.
newSequentialInstance(String) - Static method in class org.logicmachine.rebl.language.context.Scope: Convenience method which is identical to calling the 'newInstance(scopeName)' method, or subsequently invoking the 'sequential()' method.
NEXT_GID - Static variable in class org.logicmachine.rebl.domain.transactions.managers.AbstractTransactionAwareScope: To ensure the uniqueness of Global XA Transaction Xid's we use this incrementing AtomicLong along with a unique identifier and the start time.
NEXT_XID - Static variable in class org.logicmachine.rebl.domain.transactions.attributes.impl.XidImpl: To ensure the uniqueness of a transaction branch qualifier we use this incrementing AtomicLong along with a unique identifier and the start time.
NO_MATCH_FOR_KEY - Static variable in class org.logicmachine.rebl.common.i18n.ErrorMessages: Holds the error messages used when a 'Some' or 'Many' collection contains no match for a given search key.
NO_NEW_GLOBAL_TRANSACTION - Static variable in class org.logicmachine.rebl.domain.transactions.managers.AbstractTransactionAwareScope: Used to set a flag indicating that no new global transaction is required.
NO_OBSERVABLE - Static variable in class org.logicmachine.rebl.common.i18n.ErrorMessages: Holds the error message generated if an attempt is made to observe an observable which does not exist.
NO_RESOURCE - Static variable in class org.logicmachine.rebl.common.i18n.ErrorMessages: Holds the error message generated if an attempt is made to reference a resource which does not exist.
NO_SCOPE_DECLARED_FOR_ACTIONS - Static variable in class org.logicmachine.rebl.common.i18n.ErrorMessages: Holds the error message generated if an attempt is made to associate Actions to an ActiveEntity which has not firstly been associated with a Scope.
NO_SCOPE_DEFINED - Static variable in class org.logicmachine.rebl.common.i18n.ErrorMessages: Holds the error message generated if a scope is expected but not present.
NO_STATE_MACHINE - Static variable in class org.logicmachine.rebl.common.i18n.ErrorMessages: Holds the error message generated if an attempt is made to reference a state machine which does not exist.
NOT_RESPONDING - Enum constant in enum class org.logicmachine.rebl.monitor.health.HealthStatus: Indicates that some underlying resource is no longer responding.
NOT_TOP_MOST_GLOBAL_TRANSACTION - Static variable in class org.logicmachine.rebl.domain.transactions.managers.AbstractTransactionAwareScope: Used to set a flag indicating that this instance does not represent a top-level global transaction.
numberOfBranches(byte[]) - Method in class org.logicmachine.rebl.domain.transactions.resources.TransactionResource: Returns the number of transaction branches associated with the given global transaction.

O

ObservableAction - Class in org.logicmachine.rebl.domain.actions: This class allows PropertyChangeEvents to participate in the Actions which can be applied to an Entity instance.
ObservableAction() - Constructor for class org.logicmachine.rebl.domain.actions.ObservableAction: Default constructor.
ObservableAction(String) - Constructor for class org.logicmachine.rebl.domain.actions.ObservableAction: Constructor creating a notification action instance of the given 'name'.
onFailure(Exception) - Method in class org.logicmachine.rebl.domain.entities.ActiveEntity: Placeholder method hook which is invoked on error.
onSuccess() - Method in class org.logicmachine.rebl.domain.entities.ActiveEntity: Placeholder method hook which is invoked as soon as the last Action has been successfully applied.
OPEN_PARENTHESIS - Static variable in class org.logicmachine.rebl.common.Constants: Hold the open-round-bracket character.
operation() - Method in class org.logicmachine.rebl.domain.transactions.attributes.TransactionDetails: Returns the nature of the CRUD operation to be applied.
OPERATION - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the label used within toString() methods to log the operation associated with a transaction.
OrdinalComparator() - Constructor for class org.logicmachine.rebl.domain.stateMachines.StateMachine.OrdinalComparator
org.logicmachine.rebl.common - package org.logicmachine.rebl.common: This package contains a range of helper classes which are used within the main code-base.
org.logicmachine.rebl.common.i18n - package org.logicmachine.rebl.common.i18n: This package provides support for externalising user visible strings and error messages into locale-specific resource bundles.
org.logicmachine.rebl.domain.actions - package org.logicmachine.rebl.domain.actions: This package provides base classes which can be used to define Actions to be performed on ActiveEntities within a given Business Language.
org.logicmachine.rebl.domain.actors - package org.logicmachine.rebl.domain.actors: This package provides base classes which can be used to define the OwningEntities (ie Actors) which own some ActiveEntities.
org.logicmachine.rebl.domain.entities - package org.logicmachine.rebl.domain.entities: This package provides a number of base-classes used to create a range of business entities, as required to construct a Business Language.
org.logicmachine.rebl.domain.exceptions - package org.logicmachine.rebl.domain.exceptions: This package provides base classes which can be used to define a range of business exception classes and related exception handlers.
org.logicmachine.rebl.domain.resources - package org.logicmachine.rebl.domain.resources: This package provides base classes which can be used to define resources to be made available within a scope; such resources are then available for use within the business logic running within that scope.
org.logicmachine.rebl.domain.resources.support - package org.logicmachine.rebl.domain.resources.support: This package provides support for generic resource pools.
org.logicmachine.rebl.domain.stateMachines - package org.logicmachine.rebl.domain.stateMachines: This package provides support for generic finite state machines.
org.logicmachine.rebl.domain.transactions - package org.logicmachine.rebl.domain.transactions: This package provides support for Transactions.
org.logicmachine.rebl.domain.transactions.attributes - package org.logicmachine.rebl.domain.transactions.attributes: This package holds a range of classes which together provide support for the definition and usage of Transactions.
org.logicmachine.rebl.domain.transactions.attributes.impl - package org.logicmachine.rebl.domain.transactions.attributes.impl: This package holds a range of classes which together provide support for the definition and usage of Transactions.
org.logicmachine.rebl.domain.transactions.managers - package org.logicmachine.rebl.domain.transactions.managers: This package provides XA Transaction Managers which are scope aware.
org.logicmachine.rebl.domain.transactions.resources - package org.logicmachine.rebl.domain.transactions.resources: This package allows resources to be created which are aware of XA Transactions.
org.logicmachine.rebl.domain.transactions.resources.impl - package org.logicmachine.rebl.domain.transactions.resources.impl: This package provides a basic implementation of a resource which is aware of XA Transactions.
org.logicmachine.rebl.language - package org.logicmachine.rebl.language: This package provides the top-level class used to actually create a Business Language.
org.logicmachine.rebl.language.context - package org.logicmachine.rebl.language.context: This package provides placeholder classes used to store contextual data for use within the Business Language.
org.logicmachine.rebl.language.details - package org.logicmachine.rebl.language.details: This package provides the low-level language constructs associated with the Grammar and Vocabulary for this Business Language.
org.logicmachine.rebl.monitor - package org.logicmachine.rebl.monitor: This package provides classes which are used to derive metrics from the activities of other entities.
org.logicmachine.rebl.monitor.health - package org.logicmachine.rebl.monitor.health: This package provides classes which are used to monitor the health status of other entities.
org.logicmachine.rebl.monitor.impl - package org.logicmachine.rebl.monitor.impl: This package provides the implementation of a range of classes which can be used to monitor the activities of other entities by generating various metrics.
OwningEntity - Class in org.logicmachine.rebl.domain.entities: An OwningEntity 'owns' one or more ActiveEntities.
OwningEntity() - Constructor for class org.logicmachine.rebl.domain.entities.OwningEntity: Default constructor.

P

PACKAGE_SEPARATOR - Static variable in class org.logicmachine.rebl.common.Constants: Holds the character sequence used to separate standard Java package name components.
parallel() - Method in class org.logicmachine.rebl.domain.entities.ActiveEntity: Directs this instance to invoke its actions within a new thread.
parallel() - Method in class org.logicmachine.rebl.language.context.Scope: Directs this instance to invoke its actions in parallel within new threads.
parallel(Callable) - Method in class org.logicmachine.rebl.domain.entities.ActiveEntity: Directs this instance to invoke its actions within a new thread and invoke the given 'callback' upon completion.
PARALLEL_SCOPE_ENV_VARIABLE - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the name of the system environment variable which can be used to cause all new Scopes to be set to run in parallel mode.
parallelCallback - Variable in class org.logicmachine.rebl.domain.entities.ActiveEntity: For parallel invocation of this instance, a callback can be defined which will be invoked upon completion of the actions associated with this instance.
parallelParentScope - Variable in class org.logicmachine.rebl.language.context.Scope: Handle to the parent scope (can be 'empty', but non-null, if this scope has no effective parent - ie if this is the top-most default scope).
parallelThread - Variable in class org.logicmachine.rebl.domain.entities.ActiveEntity: For parallel processing, this will hold the new thread being used; otherwise this value will be null.
parallelThreadIsComplete - Variable in class org.logicmachine.rebl.domain.entities.ActiveEntity: Flag indicating the completion status of the thread used to invoke the parallel functionality.
parentOf(Scope) - Method in class org.logicmachine.rebl.language.context.Scope: Allows the parent scope to be defined for the given instance.
parentScope - Variable in class org.logicmachine.rebl.language.context.Scope: Handle to the parent scope (can be 'empty', but non-null, if this scope has no effective parent - ie if this is the top-most default scope).
PassiveEntity - Class in org.logicmachine.rebl.domain.entities: PassiveEntities are embedded within ActiveEntities and cannot be addressed directly.
PassiveEntity() - Constructor for class org.logicmachine.rebl.domain.entities.PassiveEntity: Default constructor.
PERCENTAGE_SIGN - Static variable in class org.logicmachine.rebl.common.Constants: Holds the character sequence used to denote a percentage sign.
perform(TransactionOperation, Object, Object...) - Method in class org.logicmachine.rebl.domain.transactions.ScopedTransaction: Performs the given operation within the current transaction.
performAction(PreparedStatement) - Method in class org.logicmachine.rebl.domain.transactions.managers.JdbcTransactionAwareScope: Executes the given PreparedStatement against the current database connection.
performAction(PreparedStatement, Object...) - Method in class org.logicmachine.rebl.domain.transactions.managers.JdbcTransactionAwareScope: Executes the given PreparedStatement against the current database connection.
pool - Variable in class org.logicmachine.rebl.common.Pool: Holds the underlying data collection on which this pool is based.
Pool<T> - Class in org.logicmachine.rebl.common: This class provides a basic implementation of a resource pool structure.
Pool() - Constructor for class org.logicmachine.rebl.common.Pool: Default constructor which lazily creates a fixed pool of default size (10 entries).
Pool(boolean) - Constructor for class org.logicmachine.rebl.common.Pool: Constructor which lazily creates a pool of default size (10 entries) and default increment size (10 entries).
Pool(boolean, boolean) - Constructor for class org.logicmachine.rebl.common.Pool: Constructor which creates a pool of default size (10 entries) and default increment size (10 entries).
Pool(boolean, int) - Constructor for class org.logicmachine.rebl.common.Pool: Constructor which lazily creates a pool of default size (10 entries) and default increment size (10 entries).
Pool(boolean, int, boolean) - Constructor for class org.logicmachine.rebl.common.Pool: Constructor which creates a pool of default size (10 entries) and default increment size (10 entries).
Pool(boolean, int, int) - Constructor for class org.logicmachine.rebl.common.Pool: Constructor which lazily creates a pool whose size is determined by the 'initialPoolSize' parameter and whose default increment size is set to 1/10th of this 'initialPoolSize'.
Pool(boolean, int, int, boolean) - Constructor for class org.logicmachine.rebl.common.Pool: Constructor which creates a pool whose size is determined by the 'initialPoolSize' parameter and whose default increment size is set to 1/10th of this 'initialPoolSize'.
Pool(int, int, int) - Constructor for class org.logicmachine.rebl.common.Pool: Constructor which lazily creates a pool whose size is determined by the 'initialPoolSize' parameter and whose default increment size is set to the 'poolIncrementSize' parameter.
Pool(int, int, int, boolean) - Constructor for class org.logicmachine.rebl.common.Pool: Constructor which creates a pool whose size is determined by the 'initialPoolSize' parameter and whose default increment size is set to the 'poolIncrementSize' parameter.
poolCanGrow - Variable in class org.logicmachine.rebl.common.Pool: Flag indicating if it is possible for this pool to grow (ie is it a fixed sized pool or dynamically sized).
poolIncrementSize - Variable in class org.logicmachine.rebl.common.Pool: Holds the optional pool increment size controlling how the pool grows when it fills up.
poolSize - Variable in class org.logicmachine.rebl.common.Pool: The current number of entries in the pool (which will be the sum of the count of available and in-use entries).
popTransaction(int) - Method in class org.logicmachine.rebl.domain.transactions.managers.AbstractTransactionAwareScope: Pops the top-most transaction off the transaction stack.
popTransaction(int) - Method in class org.logicmachine.rebl.domain.transactions.managers.JdbcTransactionAwareScope
popTransaction(int) - Method in class org.logicmachine.rebl.domain.transactions.managers.TransactionAwareScope: Pops the top-most transaction off the transaction stack.
popTransaction(int) - Method in class org.logicmachine.rebl.domain.transactions.managers.TransactionAwareWithWriteAheadScope
POSTGRES - Enum constant in enum class org.logicmachine.rebl.domain.transactions.attributes.SupportedDatabases: Specifies that the underlying database in use is POSTGRES.
predicate() - Method in class org.logicmachine.rebl.domain.transactions.attributes.TransactionDetails: Returns the (optional) predicate used to filter/select the entries on which this operation will be performed.
PREDICATE - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the label used within toString() methods to log the predicate associated with a transaction.
prepare(Xid) - Method in class org.logicmachine.rebl.domain.transactions.resources.impl.InMemoryXAResource: Attempts to prepare the specified transaction.
PREPARED_STATEMENT_PLACEHOLDER - Static variable in class org.logicmachine.rebl.common.Constants: Holds the character used as a value placeholder within PreparedStatements.
previousState() - Method in class org.logicmachine.rebl.domain.stateMachines.StateMachine: Returns the previous state of this state machine, or null if the state machine is still in its initial state.
process(Callable<?>) - Static method in class org.logicmachine.rebl.language.context.Scope: Causes the given 'callable' to be invoked within a newly created Thread, calling the entry-point into the application logic.
process(Callable<?>, Scope) - Static method in class org.logicmachine.rebl.language.context.Scope: Causes the given 'scope' to run the given 'callable' in a newly created Thread, calling the entry-point into the application logic and invoking this scopes exception handling mechanism on error.
PseudoTransaction(Connection) - Constructor for class org.logicmachine.rebl.domain.transactions.managers.JdbcTransactionAwareScope.PseudoTransaction: Constructor creating a transaction instance for this given 'connection'.
pushTransaction(ScopedTransaction) - Method in class org.logicmachine.rebl.domain.transactions.managers.TransactionAwareWithWriteAheadScope
pushTransaction(T) - Method in class org.logicmachine.rebl.domain.transactions.managers.AbstractTransactionAwareScope: Pushes the given transaction onto the transaction stack.

R

READ - Enum constant in enum class org.logicmachine.rebl.domain.transactions.attributes.TransactionOperation: Identifies this transaction as a Read operation.
READ_MODE - Static variable in class org.logicmachine.rebl.common.Constants: Allows the write-ahead transaction log file to be opened in read-only mode, for recovery.
READ_WRITE_MODE - Static variable in class org.logicmachine.rebl.common.Constants: Allows the write-ahead transaction log file to be opened in read/write mode.
recover(int) - Method in class org.logicmachine.rebl.domain.transactions.resources.impl.InMemoryXAResource: Returns the full contents of the (in-memory) recovery log.
recoverAnyExistingTransactions() - Method in class org.logicmachine.rebl.domain.transactions.managers.TransactionAwareWithWriteAheadScope: Check the transaction log for transactions to recover.
registerScope(Scope) - Method in class org.logicmachine.rebl.language.Language: Stores the given scope entry.
registerSynchronization(Synchronization) - Method in class org.logicmachine.rebl.domain.transactions.managers.JdbcTransactionAwareScope.PseudoTransaction
registerSynchronization(Synchronization) - Method in class org.logicmachine.rebl.domain.transactions.ScopedTransaction
releaseEntry(T) - Method in class org.logicmachine.rebl.common.Pool: This method frees up the specified resource entry, returning this resource to the available pool.
removeAllParallelActiveEntitiesForThread(ActiveEntity) - Static method in class org.logicmachine.rebl.common.Common: Removes all of the active entities associated with the given 'thread'.
removeAllParallelActiveEntitiesForThread(ActiveEntity) - Method in class org.logicmachine.rebl.language.Language: Removes all of the active entities associated with the given 'thread'.
removeAllScopeData() - Method in class org.logicmachine.rebl.language.Language: Removes all data associated with all scopes.
removeParallelActiveEntitiesFromScope(Scope) - Static method in class org.logicmachine.rebl.common.Common: Unregisters the completed parallel ActiveEntities for the given 'scope'.
removeParallelActiveEntitiesFromScope(Scope) - Method in class org.logicmachine.rebl.language.Language: Unregisters the completed parallel ActiveEntities for the given 'scope'.
REPEAT_COUNT - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the name used as a label for the repeat count within the 'toString()' method of a Repeatable.
REPEAT_FOR_ALL_EXCEPTIONS - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the name used as a label within the 'toString()' method of a Repeatable indicating that any exception type will trigger a repeat.
REPEAT_FOR_EXCEPTIONS - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the name used as a label within the 'toString()' method of a Repeatable indicating that only specific exception types will trigger a repeat.
Repeatable - Class in org.logicmachine.rebl.common: This class supports exception handling logic offering re-try functionality.
Repeatable() - Constructor for class org.logicmachine.rebl.common.Repeatable: Default constructor.
Repeatable(ActiveEntity) - Constructor for class org.logicmachine.rebl.common.Repeatable: Constructor allowing an active entity to be specified.
REPEATABLE - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the name used as a label for the Repeatable class within the corresponding 'toString()' methods.
repeatForAnyException() - Method in class org.logicmachine.rebl.common.Repeatable: Calling this method will cause this repeatable to repeat for ANY exception type.
repeatOnError() - Method in class org.logicmachine.rebl.domain.entities.ActiveEntity: A call to this method is used to denote the start of a repeatable set of action definitions.
repeatOnError(Class<? extends Exception>...) - Method in class org.logicmachine.rebl.domain.entities.ActiveEntity: A call to this method is used to denote the start of a repeatable set of action definitions.
reset() - Static method in class org.logicmachine.rebl.common.Common: Resets the platform; clearing all pre-stored data.
reset() - Method in class org.logicmachine.rebl.domain.stateMachines.StateMachine: Causes this state machine to be reset to its original 'initialState' - even if a transition from the current state to the initial state has not been explicitly defined.
resetCurrentTransaction() - Method in class org.logicmachine.rebl.domain.transactions.managers.AbstractTransactionAwareScope: Resets the 'currentTransaction' to the top-most transaction on the transaction stack (will be null if no open transactions currently exist).
RESETTING_STATE_MACHINE - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the name used as a label within the informational log message stating that a specific state machine is about to be reset.
Resource - Class in org.logicmachine.rebl.domain.resources: This class allows a single business resource to be defined.
Resource() - Constructor for class org.logicmachine.rebl.domain.resources.Resource: Default constructor.
Resource(Object) - Constructor for class org.logicmachine.rebl.domain.resources.Resource: Constructor creating a resource associated with the given 'key'.
RESOURCE_DIRECTORY - Static variable in class org.logicmachine.rebl.common.Constants: Holds the top-level directory name used to store locale-specific resource bundles.
RESOURCE_EXHAUSTED - Enum constant in enum class org.logicmachine.rebl.monitor.health.HealthStatus: Indicates that some attribute associated with this entity has been maxed out,

For example, this could be an out-of-memory condition, or could indicate that a disk partition is full, or a bounded cache has reached its limit, etc.
RESOURCE_FILE_SUFFIX - Static variable in class org.logicmachine.rebl.common.Constants: Holds the file suffix used by locale-specific resource bundles.
RESOURCE_LOCALE_DIRECTORY - Static variable in class org.logicmachine.rebl.common.Constants: Holds the sub-directory name used to store locale-specific resource bundles.
ResourceBundles - Class in org.logicmachine.rebl.common.i18n: This class defines helper methods allowing error messages and externally visible strings to be extracted into locale-specific resource bundles.
resources - Variable in class org.logicmachine.rebl.language.context.Scope: Holds the optional resources which are only visible within the current scope.
Resources - Class in org.logicmachine.rebl.domain.resources: Collection class holding a set of Resource instances.
Resources() - Constructor for class org.logicmachine.rebl.domain.resources.Resources: Default constructor.
RESOURCES - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the name used as a label for the resources within a given scope.
ResponseCode - Enum Class in org.logicmachine.rebl.domain.entities: Holds the response values which can be returned by the 'execute()', 'onSuccess()' and 'onFailure()' methods within the ActiveEntiity class.
resume(Transaction) - Method in class org.logicmachine.rebl.domain.transactions.managers.AbstractTransactionAwareScope
resume(Transaction) - Method in class org.logicmachine.rebl.domain.transactions.managers.JdbcTransactionAwareScope: Not supported by this implementation.
resume(Transaction) - Method in class org.logicmachine.rebl.domain.transactions.managers.TransactionAwareScope
resume(Xid) - Method in class org.logicmachine.rebl.domain.transactions.resources.TransactionResource: Attempts to resume the work on the previously suspended transaction identified by the 'xid' parameter.
RESUME_ACTIONS - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the name used as a label for the resume actions for a state within a state machine.
RESUMED - Enum constant in enum class org.logicmachine.rebl.monitor.health.HealthStatus: Indicates that some attribute associated with this entity was previously suspended but has now resumed.
rollback() - Method in class org.logicmachine.rebl.domain.transactions.managers.AbstractTransactionAwareScope
rollback() - Method in class org.logicmachine.rebl.domain.transactions.managers.JdbcTransactionAwareScope.PseudoTransaction
rollback() - Method in class org.logicmachine.rebl.domain.transactions.ScopedTransaction
rollback(byte[]) - Method in class org.logicmachine.rebl.domain.transactions.resources.TransactionResource: Attempts to rollback all work on the global transaction specified by 'globalXid'.
rollback(Xid) - Method in class org.logicmachine.rebl.domain.transactions.resources.impl.InMemoryXAResource: Attempts to rollback the specified transaction.
rollback(Xid) - Method in class org.logicmachine.rebl.domain.transactions.resources.TransactionResource: Attempts to rollback all work on the given transaction.
rollbackCurrentTransaction() - Method in class org.logicmachine.rebl.domain.transactions.managers.AbstractTransactionAwareScope: Attempts to rollback the top-most transaction on the transaction stack.
rollbackCurrentTransaction() - Method in class org.logicmachine.rebl.domain.transactions.managers.TransactionAwareWithWriteAheadScope
rollbackTransaction() - Method in class org.logicmachine.rebl.domain.transactions.managers.AbstractTransactionAwareScope: Attempts to rollback the top-most transaction on the transaction stack.
RUN_IN_PARALLEL - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the name used as a label for the parallel/sequential nature of a Scope or ActiveEntity.

S

SafeIterable<T> - Class in org.logicmachine.rebl.common: Provides a null-safe alternative to the standard Iterable class.
SafeIterable() - Constructor for class org.logicmachine.rebl.common.SafeIterable: Default constructor.
SafeIterable(Collection<T>) - Constructor for class org.logicmachine.rebl.common.SafeIterable: Constructs a new SafeIterable that can iterate the specified Collection.
Scope - Class in org.logicmachine.rebl.language.context: Nested scopes provide isolation for blocks of business logic.
Scope() - Constructor for class org.logicmachine.rebl.language.context.Scope: Default constructor.
Scope(String) - Constructor for class org.logicmachine.rebl.language.context.Scope: Constructor creating a new scope instance of the given 'scopeName'.
SCOPE - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the name used as a label for the scope being logged.
SCOPE_SEQUENTIAL_FAILURE_ALREADY_PARALLEL - Static variable in class org.logicmachine.rebl.common.i18n.ErrorMessages: Holds the error message generated if an attempt is made to flag a Scope as sequential when it has already previously been flagged as being parallel.
ScopeAssignable<T> - Class in org.logicmachine.rebl.common: This helper class denotes support for an element which can reference its enclosing Scope instance.
ScopeAssignable() - Constructor for class org.logicmachine.rebl.common.ScopeAssignable: Default constructor.
ScopedTransaction - Class in org.logicmachine.rebl.domain.transactions: This class represents one transaction running within a scope.
ScopedTransaction(TransactionAwareScope) - Constructor for class org.logicmachine.rebl.domain.transactions.ScopedTransaction: Constructor creating a new transaction within a transaction-aware scope.
ScopedTransaction(TransactionAwareScope, byte[], boolean) - Constructor for class org.logicmachine.rebl.domain.transactions.ScopedTransaction: Constructor creating a new transaction within a transaction-aware scope.
ScopedTransaction(TransactionAwareScope, byte[], byte[], boolean) - Constructor for class org.logicmachine.rebl.domain.transactions.ScopedTransaction: Constructor creating a new transaction within a transaction-aware scope.
ScopedTransaction(ScopedTransaction) - Constructor for class org.logicmachine.rebl.domain.transactions.ScopedTransaction: Constructor creating a new transaction within the same global transaction and using the same transaction manager as the specified existing transaction.
scopeExists(String) - Method in class org.logicmachine.rebl.language.Language: This method can be used to check if an existing Scope is associated with the given 'scopeName'.
SCOPES - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the name used as a label for the scopes within a language.
SELECT - Static variable in class org.logicmachine.rebl.common.Constants: Holds the SQL select instruction.
selfCloseThisParallelScope() - Method in class org.logicmachine.rebl.language.context.Scope: This method is called automatically to self-close parallel scopes.
SEMI_COLON - Static variable in class org.logicmachine.rebl.common.Constants: Holds the semi-colon character, used to terminate SQL statements.
sequential() - Method in class org.logicmachine.rebl.domain.entities.ActiveEntity: Directs this instance to invoke its actions in a sequential manner, provided a parallel invocation has not already been specified.
sequential() - Method in class org.logicmachine.rebl.language.context.Scope: Directs this instance to invoke its actions in a sequential manner.
SET - Static variable in class org.logicmachine.rebl.common.Constants: Holds the SQL 'set' keyword for insert instructions.
setDefaultScopeType(Class<? extends Scope>) - Static method in class org.logicmachine.rebl.language.context.Scope: Setter method used to influence the nature of scope instances created by the 'newInstance()' method.
setEmpty() - Method in class org.logicmachine.rebl.common.KeyValue: This method should be called if the underlying instance represents an empty instance.
setException(Exception) - Method in class org.logicmachine.rebl.domain.exceptions.ExceptionHandler: Stores the given 'exception' so that it is accessible from the entry actions associated with the error states.
setHandled() - Method in exception class org.logicmachine.rebl.domain.exceptions.BusinessMessage: Sets the 'isHandled' flag to true indicating that no further exception handlers need be called to process this exception.
setHandled(Exception) - Method in class org.logicmachine.rebl.domain.exceptions.ExceptionHandler: If the given 'exception' is a BusinessMesage instance, this method will set the corresponding flag to state that this exception has been successfully handled.
setRollbackOnly() - Method in class org.logicmachine.rebl.domain.transactions.managers.AbstractTransactionAwareScope
setRollbackOnly() - Method in class org.logicmachine.rebl.domain.transactions.managers.JdbcTransactionAwareScope.PseudoTransaction
setRollbackOnly() - Method in class org.logicmachine.rebl.domain.transactions.ScopedTransaction
setScopeInitialisationProperties(Class<? extends Scope>, Properties) - Static method in class org.logicmachine.rebl.language.context.Scope: Allows any scope initialisation properties to be defined by scope class type.
setScopeInitialisationProperties(Object, Properties) - Static method in class org.logicmachine.rebl.language.context.Scope: Allows any scope-specific initialisation properties to be defined before the 'newInstance()' factory method is invoked.
setTransactionTimeout(int) - Method in class org.logicmachine.rebl.domain.transactions.managers.AbstractTransactionAwareScope
setTransactionTimeout(int) - Method in class org.logicmachine.rebl.domain.transactions.managers.JdbcTransactionAwareScope: Not supported by this implementation.
setTransactionTimeout(int) - Method in class org.logicmachine.rebl.domain.transactions.managers.TransactionAwareScope
setTransactionTimeout(int) - Method in class org.logicmachine.rebl.domain.transactions.resources.impl.InMemoryXAResource: Sets the transaction timeout period for this resource.
setTransactionTimeout(int) - Method in class org.logicmachine.rebl.domain.transactions.resources.TransactionResource: Sets the current transaction timeout value for this instance.
setTransactionTimeout(int) - Method in class org.logicmachine.rebl.domain.transactions.ScopedTransaction: Sets the current transaction timeout value for this instance.
SHOULD_REPEAT_FOR_EXCEPTION - Enum constant in enum class org.logicmachine.rebl.domain.entities.ResponseCode: Signifies that an exception has been caught for which a retry handler has been defined.
shouldRepeatForException(Exception) - Method in class org.logicmachine.rebl.common.Repeatable: Checks if the given 'exception' should cause this repeatable to repeat its actions.
SHUTTING_DOWN - Enum constant in enum class org.logicmachine.rebl.monitor.health.HealthStatus: Indicates that some underlying resource is in the process of shutting down.
SINGLE_SPACE - Static variable in class org.logicmachine.rebl.common.Constants: Holds a single space character, used in toString() methods.
size() - Method in class org.logicmachine.rebl.common.Many
size() - Method in class org.logicmachine.rebl.common.Pool: If this pool is dynamically sized (ie if it can grow), then this method returns the current number of entries in this pool.
size() - Method in class org.logicmachine.rebl.common.SafeIterable: Returns the size of the underlying Collection, or zero if the underlying Collection is null.
size() - Method in class org.logicmachine.rebl.common.Some: Returns the number of elements currently held within this collection.
SLEEP_TIME_IN_MILLIS - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the name used as a label for the sleep time within the 'toString()' method of a Repeatable.
sleepOnError() - Method in class org.logicmachine.rebl.common.Repeatable: If a sleep time has previously been defined, this method will pause for the specified time period.
Some<T> - Class in org.logicmachine.rebl.common: This class is intended to be used in those circumstances where we have a relatively small collection of 'things' which we wish to refer to directly, by key.
Some() - Constructor for class org.logicmachine.rebl.common.Some: Default constructor.
Some(T...) - Constructor for class org.logicmachine.rebl.common.Some: Constructor allowing a number of 'singular' instances to be added to this collection class.
SPACE_EQUALS_SPACE - Static variable in class org.logicmachine.rebl.common.Constants: Holds a space character followed by an equals sign followed by another space, used in the Scope toString() method used to log monitor results.
SPACE_HYPHEN_SPACE - Static variable in class org.logicmachine.rebl.common.Constants: Holds a space character followed by a hyphen followed by another space, used in the Scope class to build an error message.
start(Xid, int) - Method in class org.logicmachine.rebl.domain.transactions.resources.impl.InMemoryXAResource: Starts (or resumes) the specified transaction based on the given 'flags'.
START_TIME - Static variable in class org.logicmachine.rebl.domain.transactions.attributes.impl.XidImpl: To ensure the uniqueness of a transaction branch qualifier we use this start time along with a unique identifier and an incrementing AtomicLong.
START_TIME - Static variable in class org.logicmachine.rebl.domain.transactions.managers.AbstractTransactionAwareScope: To ensure the uniqueness of Global XA Transaction Xid's we use this start time along with a unique identifier and an incrementing AtomicLong.
START_TRANSACTION - Static variable in class org.logicmachine.rebl.common.Constants: Holds the SQL 'START TRANSACTION' instruction.
STARTING_UP - Enum constant in enum class org.logicmachine.rebl.monitor.health.HealthStatus: Indicates that some underlying resource is in the process of starting up.
startRepeatable() - Method in class org.logicmachine.rebl.common.Repeatable: Defines the start of a repeatable group of actions.
STATE - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the name of the property being changed within a PropertyChangeEvent for a state transition within a state machine.
STATE_MACHINE - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the name used as a label for a state machine.
STATE_MACHINE_CURRENT_STATE - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the name used as a label for the current state of a state machine.
STATE_MACHINE_INITIAL_STATE - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the name used as a label for the starting state of a state machine.
STATE_MACHINE_SUPER_STATES - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the name used as a label for the defined super states within a state machine.
STATE_MACHINES - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the name used as a label for the state machines within a given scope.
STATE_TRANSITIONS - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the name used as a label for the defined state transitions within a state machine.
stateMachine - Variable in class org.logicmachine.rebl.domain.stateMachines.StateMachineExceptionHandler: This exception handler is based on triggering state transitions within this state machine instance.
StateMachine<T> - Class in org.logicmachine.rebl.domain.stateMachines: This class provides support for a standard finite state machine.
StateMachine() - Constructor for class org.logicmachine.rebl.domain.stateMachines.StateMachine: Default constructor.
StateMachine(String) - Constructor for class org.logicmachine.rebl.domain.stateMachines.StateMachine: Constructor, creating a StateMachine instance associated with the given (non-null, non-empty) key.
StateMachine.OrdinalComparator - Class in org.logicmachine.rebl.domain.stateMachines: Comparator used by the toString() methods to ensure consistent ordering of state enumerations.
StateMachineExceptionHandler<T> - Class in org.logicmachine.rebl.domain.stateMachines: This exception handler is backed by a finite state machine.
StateMachineExceptionHandler() - Constructor for class org.logicmachine.rebl.domain.stateMachines.StateMachineExceptionHandler: Default constructor.
StateMachineExceptionHandler(StateMachine<T>, T) - Constructor for class org.logicmachine.rebl.domain.stateMachines.StateMachineExceptionHandler: Constructor creating a new state-machine backed exception handler, whose default state transition on error will be the given 'defaultExceptionState'.
StateMachineExceptionHandler(StateMachine<T>, T, String) - Constructor for class org.logicmachine.rebl.domain.stateMachines.StateMachineExceptionHandler: Constructor creating a new state-machine backed exception handler, whose default state transition on error will be the given 'defaultExceptionState'.
stateMachines - Variable in class org.logicmachine.rebl.language.context.Scope: Holds the optional state machines associated with this scope.
StateMachines - Class in org.logicmachine.rebl.domain.stateMachines: Collection class holding a set of StateMachine instances.
StateMachines() - Constructor for class org.logicmachine.rebl.domain.stateMachines.StateMachines: Default constructor.
STATEMENT - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the name used as a label for PreparedStatements within the 'toString()' methods of the JDBC classes.
STATES - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the name used as a label for the defined states within a state machine.
StateTransitionAction - Class in org.logicmachine.rebl.domain.actions: This class allows 'StateTransition' objects to participate in the Actions which can be applied to an ActiveEntity instance.
StateTransitionAction() - Constructor for class org.logicmachine.rebl.domain.actions.StateTransitionAction: Default constructor.
StateTransitionAction(String) - Constructor for class org.logicmachine.rebl.domain.actions.StateTransitionAction: Constructor creating a StateTransition instance of the given 'name'.
STATUS_ACTIVE - Enum constant in enum class org.logicmachine.rebl.domain.transactions.attributes.TransactionStatus: A transaction is associated with this enumerated value if it is in the active state.
STATUS_COMMITTED - Enum constant in enum class org.logicmachine.rebl.domain.transactions.attributes.TransactionStatus: A transaction is associated with this enumerated value if it has been committed.
STATUS_COMMITTING - Enum constant in enum class org.logicmachine.rebl.domain.transactions.attributes.TransactionStatus: A transaction is associated with this enumerated value if it is in the process of committing.
STATUS_MARKED_ROLLBACK - Enum constant in enum class org.logicmachine.rebl.domain.transactions.attributes.TransactionStatus: A transaction is associated with this enumerated value if it has been marked for rollback, perhaps as a result of a setRollbackOnly operation.
STATUS_NO_TRANSACTION - Enum constant in enum class org.logicmachine.rebl.domain.transactions.attributes.TransactionStatus: No transaction is currently associated with the target object.
STATUS_PREPARED - Enum constant in enum class org.logicmachine.rebl.domain.transactions.attributes.TransactionStatus: A transaction is associated with this enumerated value if it has been prepared.
STATUS_PREPARING - Enum constant in enum class org.logicmachine.rebl.domain.transactions.attributes.TransactionStatus: A transaction is associated with this enumerated value if it is in the process of preparing.
STATUS_ROLLEDBACK - Enum constant in enum class org.logicmachine.rebl.domain.transactions.attributes.TransactionStatus: A transaction is associated with this enumerated value if the outcome has been determined to be rollback.
STATUS_ROLLING_BACK - Enum constant in enum class org.logicmachine.rebl.domain.transactions.attributes.TransactionStatus: A transaction is associated with this enumerated value if it is in the process of rolling back.
STATUS_UNKNOWN - Enum constant in enum class org.logicmachine.rebl.domain.transactions.attributes.TransactionStatus: A transaction is associated with this enumerated value if its current status cannot be determined.
stillAvailable - Variable in class org.logicmachine.rebl.common.Pool: Holds a count of how many free/available entries exist in the currently defined pool.
stillAvailable() - Method in class org.logicmachine.rebl.common.Pool: Returns a count of the number of elements still available in the pool.
stringOrEmptyString(Object) - Static method in class org.logicmachine.rebl.common.Common: Returns the 'toString()' of the given 'value' provided 'value' is non-null.
SupportedDatabases - Enum Class in org.logicmachine.rebl.domain.transactions.attributes: Defines the flavour of databases which are currently supported by the JDBC scope.
SUPPRESSED_ACTION - Static variable in class org.logicmachine.rebl.common.i18n.ErrorMessages: Holds the label used within an informational log message stating that an action has been suppressed because there is no available scope.
suspend() - Method in class org.logicmachine.rebl.domain.transactions.managers.AbstractTransactionAwareScope
suspend() - Method in class org.logicmachine.rebl.domain.transactions.managers.JdbcTransactionAwareScope: Not supported by this implementation.
suspend(Xid) - Method in class org.logicmachine.rebl.domain.transactions.resources.TransactionResource: Attempts to suspend all work on the specified transaction identified by the 'xid' parameter.
SUSPEND_ACTIONS - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the name used as a label for the suspend actions for a state within a state machine.
SUSPENDED - Enum constant in enum class org.logicmachine.rebl.monitor.health.HealthStatus: Indicates that some attribute associated with this entity has been suspended.

T

tearDown(Connection) - Method in class org.logicmachine.rebl.domain.resources.support.ConnectionPool
tearDown(T) - Method in class org.logicmachine.rebl.common.Pool: This (optional) method will tear-down the given 'entry', allowing any clean-up functionality to be invoked.
threadCompletionWaitTime - Variable in class org.logicmachine.rebl.domain.entities.ActiveEntity: Defines the time to wait for the parallel thread to complete.
ThreadsafeThroughputMonitor - Class in org.logicmachine.rebl.monitor.impl: This class provides a monitor which can be used to count the number of invocations of an activity.
ThreadsafeThroughputMonitor() - Constructor for class org.logicmachine.rebl.monitor.impl.ThreadsafeThroughputMonitor: Default constructor.
ThreadsafeThroughputMonitor(String) - Constructor for class org.logicmachine.rebl.monitor.impl.ThreadsafeThroughputMonitor: Constructor creating a new instance associated with the given 'key'.
threadStartUpSleepTime - Variable in class org.logicmachine.rebl.domain.entities.ActiveEntity: Within the 'waitForCompletion()' method, this value defines the sleep time to wait for a parallel thread to start.
ThroughputMonitor - Class in org.logicmachine.rebl.monitor.impl: This class provides a monitor which can be used to count the number of invocations of an activity.
ThroughputMonitor() - Constructor for class org.logicmachine.rebl.monitor.impl.ThroughputMonitor: Default constructor.
ThroughputMonitor(String) - Constructor for class org.logicmachine.rebl.monitor.impl.ThroughputMonitor: Constructor creating a new instance associated with the given 'key'.
TIMED_OUT - Enum constant in enum class org.logicmachine.rebl.monitor.health.HealthStatus: Indicates that some underlying entity has timed-out.
toString() - Method in class org.logicmachine.rebl.common.KeyValue
toString() - Method in class org.logicmachine.rebl.common.Repeatable
toString() - Method in class org.logicmachine.rebl.common.Some
toString() - Method in class org.logicmachine.rebl.domain.stateMachines.StateMachine
toString() - Method in class org.logicmachine.rebl.domain.transactions.attributes.impl.TransactionActionImpl
toString() - Method in class org.logicmachine.rebl.domain.transactions.attributes.impl.XidImpl
toString() - Method in class org.logicmachine.rebl.domain.transactions.attributes.TransactionDetails
toString() - Method in class org.logicmachine.rebl.domain.transactions.resources.impl.InMemoryXAResource
toString() - Method in class org.logicmachine.rebl.domain.transactions.resources.TransactionResource
toString() - Method in class org.logicmachine.rebl.language.Language
toString() - Method in class org.logicmachine.rebl.monitor.health.Health: Returns a string representation of this instance.
toString() - Method in class org.logicmachine.rebl.monitor.impl.DurationMonitor
toString() - Method in class org.logicmachine.rebl.monitor.impl.HealthMonitor
toString() - Method in class org.logicmachine.rebl.monitor.impl.ThreadsafeThroughputMonitor
toString() - Method in class org.logicmachine.rebl.monitor.impl.ThroughputMonitor
toString() - Method in class org.logicmachine.rebl.monitor.Monitor: Returns a string representation of this monitor, including any value(s) generated by the execution of this monitor.
toString(int) - Method in class org.logicmachine.rebl.common.KeyValue: Returns a formatted string representation of the contents of this class.
toString(int) - Method in class org.logicmachine.rebl.common.Many
toString(int) - Method in class org.logicmachine.rebl.common.Repeatable: Returns a formatted string representation of the contents of this class.
toString(int) - Method in class org.logicmachine.rebl.common.Some: Returns a formatted string representation of the contents of this class.
toString(int) - Method in class org.logicmachine.rebl.domain.actions.Callable
toString(int) - Method in class org.logicmachine.rebl.domain.entities.ActiveEntity: Returns a formatted string representation of the contents of this class.
toString(int) - Method in class org.logicmachine.rebl.domain.stateMachines.StateMachine
toString(int) - Method in class org.logicmachine.rebl.domain.transactions.attributes.impl.TransactionActionImpl
toString(int) - Method in class org.logicmachine.rebl.domain.transactions.attributes.impl.XidImpl: Returns a string representation of this object, indented to the specified level, where each level of indentation corresponds to 4 spaces.
toString(int) - Method in class org.logicmachine.rebl.domain.transactions.attributes.TransactionDetails: Returns a string representation of this instance indented to the specified level.
toString(int) - Method in class org.logicmachine.rebl.domain.transactions.managers.JdbcTransactionAwareScope
toString(int) - Method in class org.logicmachine.rebl.domain.transactions.managers.TransactionAwareScope
toString(int) - Method in class org.logicmachine.rebl.domain.transactions.resources.impl.InMemoryXAResource
toString(int) - Method in class org.logicmachine.rebl.domain.transactions.resources.TransactionResource
toString(int) - Method in class org.logicmachine.rebl.domain.transactions.ScopedTransaction
toString(int) - Method in class org.logicmachine.rebl.language.context.Scope
toString(int) - Method in class org.logicmachine.rebl.language.Language: This method returns a detailed description of the business entities and business functionality contained within this language, indented to the specified level.
toString(int) - Method in class org.logicmachine.rebl.monitor.health.Health: Returns a string representation of this instance, with suitable indentation applied.
toString(int) - Method in class org.logicmachine.rebl.monitor.impl.DurationMonitor
toString(int) - Method in class org.logicmachine.rebl.monitor.impl.HealthMonitor
toString(int) - Method in class org.logicmachine.rebl.monitor.impl.ThreadsafeThroughputMonitor
toString(int) - Method in class org.logicmachine.rebl.monitor.impl.ThroughputMonitor
toString(int) - Method in class org.logicmachine.rebl.monitor.Monitor: Returns a string representation of this monitor, including any value(s) generated by the execution of this monitor, with suitable indentation applied.
toString(int, boolean) - Method in class org.logicmachine.rebl.common.KeyValue: Returns a formatted string representation of the contents of this class, terminated with an optional newline.
toString(int, KeyValue) - Static method in class org.logicmachine.rebl.common.KeyValue: Returns the 'toString()' value of the given 'keyValue' instance, terminated with a newline character sequence.
toString(String, int) - Method in class org.logicmachine.rebl.common.ScopeAssignable: This method returns a string describing the entities contained within this instance, indented to the specified level.
toString(KeyValue) - Static method in class org.logicmachine.rebl.common.KeyValue: Returns the 'toString()' value of the given 'keyValue' instance, terminated with a newline character sequence.
TRANSACTION_ACTION - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the name used as a label for TransactionAction values within the corresponding 'toString()' methods.
TRANSACTION_CANNOT_BE_ADDED - Static variable in class org.logicmachine.rebl.common.i18n.ErrorMessages: Holds the error message generated if a transaction cannot be added to a branch within an XA transaction.
TRANSACTION_DETAILS - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the name used as a label for TransactionDetail values within the corresponding 'toString()' methods.
TRANSACTION_DUPLICATE_XID - Static variable in class org.logicmachine.rebl.common.i18n.ErrorMessages: Holds the error message generated if an attempt is made to add a transaction with a duplicate XID to a branch within an XA transaction.
TRANSACTION_ERROR_INVALID_TRANSACTION - Static variable in class org.logicmachine.rebl.common.i18n.ErrorMessages: Holds the error message generated if an attempt is made to resume a local transaction without an existing global transaction.
TRANSACTION_ERROR_NO_GLOBAL_TRANSACTION - Static variable in class org.logicmachine.rebl.common.i18n.ErrorMessages: Holds the error message generated if an attempt is made to begin a local transaction without an existing global transaction.
TRANSACTION_FAILED_TO_CLOSE - Static variable in class org.logicmachine.rebl.common.i18n.ErrorMessages: Holds the error message generated if an attempt to close a transaction generates an error.
TRANSACTION_FAILED_TO_COMMIT - Static variable in class org.logicmachine.rebl.common.i18n.ErrorMessages: Holds the error message generated if an attempt to commit a transaction generates an error.
TRANSACTION_FAILED_TO_END - Static variable in class org.logicmachine.rebl.common.i18n.ErrorMessages: Holds the error message generated if an attempt to end a transaction generates an error.
TRANSACTION_FAILED_TO_FORGET - Static variable in class org.logicmachine.rebl.common.i18n.ErrorMessages: Holds the error message generated if an attempt to forget a transaction generates an error.
TRANSACTION_FAILED_TO_JOIN - Static variable in class org.logicmachine.rebl.common.i18n.ErrorMessages: Holds the error message generated if an attempt is made to join a transaction which has not yet started.
TRANSACTION_FAILED_TO_PREPARE - Static variable in class org.logicmachine.rebl.common.i18n.ErrorMessages: Holds the error message generated if an attempt to prepare a transaction generates an error.
TRANSACTION_FAILED_TO_RECOVER - Static variable in class org.logicmachine.rebl.common.i18n.ErrorMessages: Holds the error message generated if an attempt to close a transaction recovery operation generates an error.
TRANSACTION_FAILED_TO_RESUME - Static variable in class org.logicmachine.rebl.common.i18n.ErrorMessages: Holds the error message generated if an attempt to resume a transaction generates an error.
TRANSACTION_FAILED_TO_ROLLBACK - Static variable in class org.logicmachine.rebl.common.i18n.ErrorMessages: Holds the error message generated if an attempt to rollback a transaction generates an error.
TRANSACTION_FAILED_TO_START - Static variable in class org.logicmachine.rebl.common.i18n.ErrorMessages: Holds the error message generated if an attempt to start a transaction generates an error.
TRANSACTION_FAILED_TO_SUSPEND - Static variable in class org.logicmachine.rebl.common.i18n.ErrorMessages: Holds the error message generated if an attempt to suspend a transaction generates an error.
TRANSACTION_LOG_DATE_FORMAT - Static variable in class org.logicmachine.rebl.common.Constants: Holds the date/time format used within the names of the files used to store the transaction logs.
TRANSACTION_LOG_DIRECTORY - Static variable in class org.logicmachine.rebl.common.Constants: Holds the top-level directory name used to store the transaction logs.
TRANSACTION_LOG_FAILED_TO_CREATE_DIRECTORY - Static variable in class org.logicmachine.rebl.common.i18n.ErrorMessages: Holds the error message generated on failure to create the transaction logfile directory.
TRANSACTION_LOG_FAILED_TO_DELETE - Static variable in class org.logicmachine.rebl.common.i18n.ErrorMessages: Holds the error message generated on failure to remove a transaction logfile.
TRANSACTION_LOG_FILE_SUFFIX - Static variable in class org.logicmachine.rebl.common.Constants: Holds the file suffix used by the transaction log files.
TRANSACTION_UNKNOWN_GLOBAL_TRANSACTION - Static variable in class org.logicmachine.rebl.common.i18n.ErrorMessages: Holds the error message generated if an attempt is made to begin an unknown global transaction.
TRANSACTION_UNSUPPORTED_NESTED_TRANSACTION - Static variable in class org.logicmachine.rebl.common.i18n.ErrorMessages: Holds the error message generated if an attempt is made to create a nested transaction whilst using a Transaction Manager which does not support nested transactions.
TransactionAction - Interface in org.logicmachine.rebl.domain.transactions.attributes: Provides the ability to perform an action within the context of a transaction.
TransactionActionImpl - Class in org.logicmachine.rebl.domain.transactions.attributes.impl: Provides the ability to perform an action within the context of a JDBC transaction.
TransactionActionImpl() - Constructor for class org.logicmachine.rebl.domain.transactions.attributes.impl.TransactionActionImpl
TransactionAwareScope - Class in org.logicmachine.rebl.domain.transactions.managers: Nested scopes provide isolation for blocks of business logic.
TransactionAwareScope(String) - Constructor for class org.logicmachine.rebl.domain.transactions.managers.TransactionAwareScope: Constructor creating a new scope instance of the given 'scopeName'.
TransactionAwareScope(String, boolean) - Constructor for class org.logicmachine.rebl.domain.transactions.managers.TransactionAwareScope: Constructor creating a new scope instance of the given 'scopeName'.
TransactionAwareWithWriteAheadScope - Class in org.logicmachine.rebl.domain.transactions.managers: Nested scopes provide isolation for blocks of business logic.
TransactionAwareWithWriteAheadScope() - Constructor for class org.logicmachine.rebl.domain.transactions.managers.TransactionAwareWithWriteAheadScope: Default constructor.
TransactionAwareWithWriteAheadScope(String) - Constructor for class org.logicmachine.rebl.domain.transactions.managers.TransactionAwareWithWriteAheadScope: Constructor creating a new scope instance of the given 'scopeName'.
TransactionAwareWithWriteAheadScope(String, boolean) - Constructor for class org.logicmachine.rebl.domain.transactions.managers.TransactionAwareWithWriteAheadScope: Constructor creating a new scope instance of the given 'scopeName'.
TransactionDetails - Class in org.logicmachine.rebl.domain.transactions.attributes: Placeholder for all of the attributes associated with one transaction.
TransactionDetails() - Constructor for class org.logicmachine.rebl.domain.transactions.attributes.TransactionDetails: Default constructor.
TransactionDetails(String, TransactionOperation) - Constructor for class org.logicmachine.rebl.domain.transactions.attributes.TransactionDetails: Constructor allowing a specific command to be passed down to the underlying transaction resource.
TransactionDetails(TransactionOperation, Object) - Constructor for class org.logicmachine.rebl.domain.transactions.attributes.TransactionDetails: Constructor allowing a CRUD operation and associated entity to be defined.
TransactionDetails(TransactionOperation, Object, Object...) - Constructor for class org.logicmachine.rebl.domain.transactions.attributes.TransactionDetails: Constructor allowing a CRUD operation and associated entity to be defined.
transactionLogfile - Variable in class org.logicmachine.rebl.domain.transactions.managers.TransactionAwareWithWriteAheadScope: Handle to the output file used to log transaction entries for this instance.
transactionLogFilename - Variable in class org.logicmachine.rebl.domain.transactions.managers.TransactionAwareWithWriteAheadScope: Holds the full canonical name of the file used to hold the write-ahead log for this instance.
TransactionLogFilenameFilter - Class in org.logicmachine.rebl.domain.transactions.managers: Helper class used to filter transaction log filenames based on the name of this scope instance, so that we only try to recover our own transaction logs.
TransactionLogFilenameFilter() - Constructor for class org.logicmachine.rebl.domain.transactions.managers.TransactionLogFilenameFilter: Default constructor.
TransactionLogFilenameFilter(String) - Constructor for class org.logicmachine.rebl.domain.transactions.managers.TransactionLogFilenameFilter: Constructor.
TransactionOperation - Enum Class in org.logicmachine.rebl.domain.transactions.attributes: This enumeration specifies the CRUD operations which can be applied within a transaction.
TransactionResource - Class in org.logicmachine.rebl.domain.transactions.resources: This class wraps a resource capable of participating in an XA Transaction.
TransactionResource() - Constructor for class org.logicmachine.rebl.domain.transactions.resources.TransactionResource: Default constructor.
transactions - Variable in class org.logicmachine.rebl.domain.transactions.managers.AbstractTransactionAwareScope: Holds all of the open transactions associated with this scope in a last-in-first-out stack.
TRANSACTIONS - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the name used as a label for the transactions within a given scope.
TRANSACTIONS_STATUS_STATE_MACHINE - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the name used as a label for the state machine used to track the status of transactions within a given scope.
TransactionStatus - Enum Class in org.logicmachine.rebl.domain.transactions.attributes: This enumeration represents the various states of a transaction running within a scope.
TransactionXAResource - Interface in org.logicmachine.rebl.domain.transactions.resources: Marker interface which identifies a resource as being able to participate in an XA transaction.

U

UNDERSCORE_CHARACTER - Static variable in class org.logicmachine.rebl.common.Constants: Holds the character sequence used to build the names of locale-specific resource bundles.
UNDO_ACTIONS - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the name used as a label for the undo actions within the 'toString()' method of a Repeatable.
UNKNOWN - Enum constant in enum class org.logicmachine.rebl.monitor.health.HealthStatus: Specifies an 'unknown' health status.
UNKNOWN_PROPERTY - Static variable in class org.logicmachine.rebl.common.Constants: Holds the character sequence used to denote an unknown (ie undefined) property which has been referenced, but does not exist in any resource bundle.
unregisterScope(Scope) - Static method in class org.logicmachine.rebl.common.Common: This method will unregister the given 'scope', clearing all of the associated scope data and returning a handle to the parent scope (which could be a non-null 'empty' scope instance).
unregisterScope(Scope) - Method in class org.logicmachine.rebl.domain.resources.Resource: This method will remove the given 'scope' instance from the list of scopes associated with this Resource instance.
unregisterScope(Scope) - Method in class org.logicmachine.rebl.language.Language: Unregisters the given 'scope', closing any CloseableResources associated with this scope and clearing all related scope data; returning the parent of this scope (which may be a non-null 'empty' instance).
unregisterThisScope(Scope) - Method in class org.logicmachine.rebl.language.Language: Unregisters the given 'scope' from this Language instance.
up() - Static method in class org.logicmachine.rebl.monitor.health.Health: Convenience method which can be used to create a health status of 'UP'.
UP - Enum constant in enum class org.logicmachine.rebl.monitor.health.HealthStatus: Indicates that some underlying entity is currently up.
update(HealthStatus) - Method in class org.logicmachine.rebl.monitor.impl.HealthMonitor: Updates the health status to 'newStatus'.
update(HealthStatus, Exception) - Method in class org.logicmachine.rebl.monitor.impl.HealthMonitor: Updates the health status to 'newStatus' and sets the optional cause of this status to 'reason' (which can be null).
UPDATE - Enum constant in enum class org.logicmachine.rebl.domain.transactions.attributes.TransactionOperation: Identifies this transaction as an Update operation.
UPDATE_TABLE - Static variable in class org.logicmachine.rebl.common.Constants: Holds the SQL update instruction.
USER_REQUESTED_SHUTDOWN - Enum constant in enum class org.logicmachine.rebl.monitor.health.HealthStatus: Indicates that some underlying resource is responding to a user shutdown request.

V

value() - Method in class org.logicmachine.rebl.domain.transactions.attributes.TransactionDetails: Returns the (first) value added.
value() - Method in class org.logicmachine.rebl.language.context.EnvironmentObject: Getter method returning the Object wrapped by this instance.
valueOf(String) - Static method in enum class org.logicmachine.rebl.common.EmptyEnum: Returns the enum constant of this class with the specified name.
valueOf(String) - Static method in enum class org.logicmachine.rebl.domain.entities.ResponseCode: Returns the enum constant of this class with the specified name.
valueOf(String) - Static method in enum class org.logicmachine.rebl.domain.transactions.attributes.SupportedDatabases: Returns the enum constant of this class with the specified name.
valueOf(String) - Static method in enum class org.logicmachine.rebl.domain.transactions.attributes.TransactionOperation: Returns the enum constant of this class with the specified name.
valueOf(String) - Static method in enum class org.logicmachine.rebl.domain.transactions.attributes.TransactionStatus: Returns the enum constant of this class with the specified name.
valueOf(String) - Static method in enum class org.logicmachine.rebl.monitor.health.HealthStatus: Returns the enum constant of this class with the specified name.
values() - Static method in enum class org.logicmachine.rebl.common.EmptyEnum: Returns an array containing the constants of this enum class, in the order they are declared.
values() - Static method in enum class org.logicmachine.rebl.domain.entities.ResponseCode: Returns an array containing the constants of this enum class, in the order they are declared.
values() - Static method in enum class org.logicmachine.rebl.domain.transactions.attributes.SupportedDatabases: Returns an array containing the constants of this enum class, in the order they are declared.
values() - Method in class org.logicmachine.rebl.domain.transactions.attributes.TransactionDetails: Returns all of the values associated with this transaction.
values() - Static method in enum class org.logicmachine.rebl.domain.transactions.attributes.TransactionOperation: Returns an array containing the constants of this enum class, in the order they are declared.
values() - Static method in enum class org.logicmachine.rebl.domain.transactions.attributes.TransactionStatus: Returns an array containing the constants of this enum class, in the order they are declared.
values() - Static method in enum class org.logicmachine.rebl.monitor.health.HealthStatus: Returns an array containing the constants of this enum class, in the order they are declared.
VALUES - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the label used within toString() methods to log the values associated with a transaction.
verifyPreConditions() - Method in class org.logicmachine.rebl.domain.actions.Action: Where appropriate, derived classes should invoke this method from within their 'doAction()' methods.
Vocabulary<T> - Interface in org.logicmachine.rebl.language.details: This is a placeholder interface defining any specific vocabulary supported by the language.

W

waitForAllParallelActiveEntities() - Static method in class org.logicmachine.rebl.common.Common: If any ActiveEntity instances associated with any Scope have previously been declared as parallel, this method will wait until all such ActiveEntities have completed, before returning.
waitForCompletion() - Method in class org.logicmachine.rebl.domain.entities.ActiveEntity: For parallel invocations, this method will wait for the new thread to complete.
waitForParallelActiveEntitiesForScope(Scope) - Static method in class org.logicmachine.rebl.common.Common: If any ActiveEntity instances associated with the given 'scope' have previously been declared as parallel, this method will wait until all such ActiveEntities have completed, before returning.
waitForParallelActiveEntitiesForScope(Scope) - Method in class org.logicmachine.rebl.language.Language: If any ActiveEntity instances associated with the given 'scope' have previously been declared as parallel, this method will wait until all such ActiveEntities have completed, before returning.
WARNING - Enum constant in enum class org.logicmachine.rebl.monitor.health.HealthStatus: Specifies a 'warning' state.
WHERE_CLAUSE - Static variable in class org.logicmachine.rebl.common.Constants: Holds the SQL 'where' clause.
withAction(Action) - Method in class org.logicmachine.rebl.domain.entities.ActiveEntity: This method allows the given 'action' to be defined, subsequently allowing this 'action' to be applied to this ActiveEntity instance.
withActions() - Method in class org.logicmachine.rebl.domain.entities.ActiveEntity: Returns the collection of Action instances previously added to this instance for the current namespace.
withActions(Action...) - Method in class org.logicmachine.rebl.domain.entities.ActiveEntity: This method allows the given 'actions' to be defined, subsequently allowing these 'actions' to be applied to this ActiveEntity instance.
withActions(Actions) - Method in class org.logicmachine.rebl.domain.entities.ActiveEntity: This method allows the given 'actions' to be defined, subsequently allowing these 'actions' to be applied to this ActiveEntity instance.
withActiveActor() - Method in class org.logicmachine.rebl.language.context.Scope: Returns a handle to the currently active Actor instance.
withActiveEntity() - Method in class org.logicmachine.rebl.domain.actions.Action: Returns a handle to the ActiveEntity which owns this Action instance.
withActiveEntity() - Method in class org.logicmachine.rebl.language.context.Scope: Returns the non-null currently active entity.
withActiveEntity(Object) - Method in class org.logicmachine.rebl.domain.entities.OwningEntity: Searches the ActiveEntity instances associated with this 'OwningEntity', selecting the first match or a non-null 'empty' instance on no match.
withActiveEntity(Object) - Method in class org.logicmachine.rebl.language.context.Scope: Sets the currently active entity to be the ActiveEntity matching the given 'key' within the currently active Actor.
withActiveEntity(Actor) - Method in class org.logicmachine.rebl.language.context.Scope: Sets the currently active entity to be the result of invoking the 'getActiveEntity()' method on the currently active Actor.
withActiveEntity(Actor, Object) - Method in class org.logicmachine.rebl.language.context.Scope: Sets the currently active actor to the given 'actor' instance.
withActiveEntity(ActiveEntity) - Method in class org.logicmachine.rebl.domain.actions.Action: This Action is associated with, and will operate on, the given 'activeEntity'.
withActiveEntity(ActiveEntity) - Method in class org.logicmachine.rebl.domain.actions.FlagExceptionHandledAction
withActiveEntity(ActiveEntity) - Method in class org.logicmachine.rebl.domain.actions.LogExceptionAction
withActiveEntity(ActiveEntity) - Method in class org.logicmachine.rebl.domain.actions.StateTransitionAction
withActiveEntity(ActiveEntity) - Method in class org.logicmachine.rebl.language.context.Scope: Sets the currently active entity.
withActiveEntityForActor(Class<? extends Entity>, Object, Object) - Method in class org.logicmachine.rebl.language.context.Scope: This is a convenience method which sets both the currently active actor and currently active entity.
withActiveExceptionHandler() - Method in class org.logicmachine.rebl.language.context.Scope: If an exception has been caught within this scope instance and exception handler(s) have been defined, this method will return a handle to the exception handler which is currently trying to process this exception.
withActiveResource() - Method in class org.logicmachine.rebl.language.context.Scope: Returns a handle to the currently active Resource instance.
withActiveResource(Resource) - Method in class org.logicmachine.rebl.language.context.Scope: Allows the given 'resource' to be attached to the current scope, with the given 'resource' becoming the currently active resource.
withActor(Class<? extends Entity>, Object) - Method in class org.logicmachine.rebl.language.context.Scope: Attempts to locate an object of the specified 'clazz' and with the given 'key' within the business entities associated with the current scope.
withActor(Actor) - Method in class org.logicmachine.rebl.language.context.Scope: Sets the currently active actor.
withActor(Actor) - Method in class org.logicmachine.rebl.language.details.Grammar: Returns a non-null 'OwningEntity' for the given 'actor'.
withArguments(Object...) - Method in class org.logicmachine.rebl.domain.actions.Callable: Setter method allowing optional parameter values to be defined, which will be passed into the method call during invocation.
withAttributes(Object...) - Method in class org.logicmachine.rebl.domain.transactions.attributes.TransactionDetails: Setter method allowing any relevant attributes to be defined.
withBranchQualifier(byte[]) - Method in class org.logicmachine.rebl.domain.transactions.attributes.impl.XidImpl: Setter method allowing a 'branchQualifier' to be specified for an Xid whose global transaction has been predefined.
withCallable(Callable) - Method in class org.logicmachine.rebl.language.context.Scope: This method allows the given Callable to be immediately launched for this instance.
withComponentPackageName(String) - Method in class org.logicmachine.rebl.language.context.Scope: Adds the fully qualified 'packageName' to the list of packages to be searched for components invoked via the 'call()' methods (within the current scope only).
withComponentPackageNames() - Method in class org.logicmachine.rebl.language.context.Scope: Returns the list of package names for the current package where Components are to be located, or an empty non-null list if no package names have been defined.
withComponentPackageNames(String...) - Method in class org.logicmachine.rebl.language.context.Scope: Adds the fully qualified 'packageNames' to the list of packages to be searched for components invoked via the 'call()' methods (within the current scope only).
withConnectionProperties(Properties) - Method in class org.logicmachine.rebl.domain.resources.support.ConnectionPool: Setter method allowing any database-specific connection name/value pairs to be defined, such as username and password.
withCurrentScope() - Method in class org.logicmachine.rebl.domain.entities.ActiveEntity: Returns the currently active Scope instance.
withDbConnectionURI(String) - Method in class org.logicmachine.rebl.domain.resources.support.ConnectionPool: Setter method allowing a well-formed database connection URI to be defined for the underlying database.
withDefaultScope() - Static method in class org.logicmachine.rebl.common.Common: Returns the initial (ie default) scope instance for this language.
withDefaultScope() - Method in class org.logicmachine.rebl.language.Language: Returns the top-level default scope instance for this language.
withEntities(Entities) - Method in class org.logicmachine.rebl.language.context.Scope: Allows a set of entities to be attached to the current scope.
withEntities(Entity...) - Method in class org.logicmachine.rebl.language.context.Scope: Allows a set of entities to be attached to the current scope.
withEntity(Entity) - Method in class org.logicmachine.rebl.domain.actions.ObservableAction: Defines the observable Entity instance to which this notification action applies.
withEntity(Entity) - Method in class org.logicmachine.rebl.language.context.Scope: Allows an entity to be attached to the current scope.
withEntryActions(T, Actions) - Method in class org.logicmachine.rebl.domain.stateMachines.StateMachine: Allows actions to be specified which will be triggered when entering the given state.
withEnvironmentObject(Object, Object) - Method in class org.logicmachine.rebl.language.context.Scope: Allows the given key/value pair to be added to the environment for the current scope.
withEnvironmentObject(EnvironmentObject) - Method in class org.logicmachine.rebl.language.context.Scope: Allows the given environment object to be attached to the current scope.
withEnvironmentObjects() - Method in class org.logicmachine.rebl.language.context.Scope: Returns the set of environment objects associated with this scope, or an empty non-null list if no environment objects have been defined.
withEnvironmentObjects(EnvironmentObject...) - Method in class org.logicmachine.rebl.language.context.Scope: Allows the given environment objects to be attached to the current scope.
withEnvironmentObjects(EnvironmentObjects) - Method in class org.logicmachine.rebl.language.context.Scope: Allows the given environment objects to be attached to the current scope.
withErrorStream(PrintStream) - Static method in class org.logicmachine.rebl.common.Common: Allows the system error stream to be reset to the given error stream.
withException(Exception) - Method in class org.logicmachine.rebl.domain.actions.LogExceptionAction: Allows an exception to be defined for this action.
withException(BusinessMessage) - Method in class org.logicmachine.rebl.domain.actions.FlagExceptionHandledAction: Allows an exception to be defined for this action.
withExceptionClass(Class<? extends Exception>) - Method in class org.logicmachine.rebl.domain.exceptions.ExceptionMatcher: Setter method for this ExceptionMatcher allowing an exception class to be defined as a matching criteria for this matcher.
withExceptionHandler(ExceptionHandler) - Method in class org.logicmachine.rebl.language.context.Scope: Allows the given exception handler to be attached to the current scope.
withExceptionHandlers() - Method in class org.logicmachine.rebl.language.context.Scope: Returns the set of exception handlers associated with this scope, or an empty non-null list if no exception handlers have been defined.
withExceptionHandlers(ExceptionHandler...) - Method in class org.logicmachine.rebl.language.context.Scope: Allows the given exception handlers to be attached to the current scope.
withExceptionHandlers(ExceptionHandlers) - Method in class org.logicmachine.rebl.language.context.Scope: Allows the given exception handlers to be attached to the current scope.
withExitActions(T, Actions) - Method in class org.logicmachine.rebl.domain.stateMachines.StateMachine: Allows actions to be specified which will be triggered when leaving the given state.
withGlobalEnvironmentObject(Object) - Method in class org.logicmachine.rebl.language.Language: Allows the given environment object to be added to the global environment.
withGlobalEnvironmentObject(EnvironmentObject) - Method in class org.logicmachine.rebl.language.Language: Allows the given environment object to be added to the global environment.
withGlobalEnvironmentObjects() - Method in class org.logicmachine.rebl.language.Language: Returns the set of global environment objects as a 'EnvironmentObjects' collection.
withGlobalEnvironmentObjects(Object...) - Method in class org.logicmachine.rebl.language.Language: Allows the given environment objects to be added to the global environment.
withGlobalEnvironmentObjects(EnvironmentObject...) - Method in class org.logicmachine.rebl.language.Language: Allows the given environment objects to be added to the global environment.
withGlobalObjects() - Method in class org.logicmachine.rebl.language.Language: Returns the set of objects within the global environment as a list of 'EnvironmentObject' objects.
withGrammar() - Method in class org.logicmachine.rebl.language.Language: Returns a handle to the grammar instance associated with this Language.
withHealthStatus(HealthStatus) - Method in class org.logicmachine.rebl.monitor.health.Health: Updates the current status of this Health instance to the given 'healthStatus'.
withInitialState(T) - Method in class org.logicmachine.rebl.domain.stateMachines.StateMachine: Setter method allowing the initial starting state of this state machine to be defined.
withKey(Object) - Method in class org.logicmachine.rebl.common.KeyValue: Allows the given 'key' to be defined for this instance.
withKey(Object) - Method in class org.logicmachine.rebl.common.LanguageAssignable
withKey(Object) - Method in class org.logicmachine.rebl.domain.actions.Action
withKey(Object) - Method in class org.logicmachine.rebl.domain.actions.Callable: Setter method defining the name of this Callable, where the name must match the format: "SimpleClassName::MethodName".
withKey(Object) - Method in class org.logicmachine.rebl.domain.entities.Entity
withKey(Object) - Method in class org.logicmachine.rebl.domain.exceptions.ExceptionHandler
withKey(Object) - Method in class org.logicmachine.rebl.domain.exceptions.ExceptionMatcher
withKey(Object) - Method in class org.logicmachine.rebl.domain.resources.Resource
withKey(Object) - Method in class org.logicmachine.rebl.domain.stateMachines.StateMachineExceptionHandler
withKey(Object) - Method in class org.logicmachine.rebl.domain.transactions.ScopedTransaction
withKey(Object) - Method in class org.logicmachine.rebl.language.context.EnvironmentObject
withKey(Object) - Method in class org.logicmachine.rebl.monitor.health.Health
withKey(Object) - Method in class org.logicmachine.rebl.monitor.Monitor
withLanguage() - Static method in class org.logicmachine.rebl.common.Common: Returns a handle to the Language in use.
withLanguage(Language) - Method in class org.logicmachine.rebl.common.LanguageAssignable: Allows the 'language' to be defined for this instance.
withListener(PropertyChangeListener) - Method in class org.logicmachine.rebl.domain.actions.ObservableAction: Allows a listener to be defined which will be notified of updates applied to the previously specified Entity.
withListeners(PropertyChangeListener...) - Method in class org.logicmachine.rebl.domain.actions.ObservableAction: Allows observers to be defined which will be notified of updates applied to the previously specified Entity.
withLocale() - Static method in class org.logicmachine.rebl.common.Common: Returns the locale associated with the Language, which defaults to the system default unless otherwise specified.
withLocale() - Method in class org.logicmachine.rebl.language.Language: Returns the locale associated with this Language instance.
withLocale(Locale) - Method in class org.logicmachine.rebl.language.Language: Setter method allowing a locale to be defined for this Language instance.
withMatcher(ExceptionMatcher) - Method in class org.logicmachine.rebl.domain.exceptions.ExceptionHandler: Allows a matcher to be defined for this instance.
withMessage(String) - Method in class org.logicmachine.rebl.domain.actions.LogExceptionAction: Allows the log message to be defined for this action.
withMessage(String) - Method in class org.logicmachine.rebl.domain.exceptions.ExceptionHandler: Setter method for this ExceptionHandler allowing a message to be defined as a prefix to any logging message.
withMessage(String) - Method in class org.logicmachine.rebl.domain.exceptions.ExceptionMatcher: A match will occur if the exception matches the expected exception class and (optionally) if the 'getMessage()' or 'getLocalizedMessage()' method results contain the given 'message'.
withMonitor(Monitor<?>) - Method in class org.logicmachine.rebl.domain.entities.ActiveEntity: This method allows the given 'monitor' to be defined, subsequently allowing this 'monitor' to be notified of processing activities.
withMonitor(Monitor<?>) - Method in class org.logicmachine.rebl.language.context.Scope: This method allows the given 'monitor' to be defined, subsequently allowing this 'monitor' to be notified of processing activities.
withMonitors() - Method in class org.logicmachine.rebl.domain.entities.ActiveEntity: Returns the collection of Monitor instances previously added to this instance.
withMonitors() - Method in class org.logicmachine.rebl.language.context.Scope: Returns the collection of Monitor instances previously added to this instance.
withMonitors(Monitor<?>...) - Method in class org.logicmachine.rebl.domain.entities.ActiveEntity: This method allows the given 'monitors' to be defined, subsequently allowing these 'monitors' to be notified of processing activities.
withMonitors(Monitor<?>...) - Method in class org.logicmachine.rebl.language.context.Scope: This method allows the given 'monitors' to be defined, subsequently allowing these 'monitors' to be notified of processing activities.
withMonitors(Monitors) - Method in class org.logicmachine.rebl.domain.entities.ActiveEntity: This method allows the given 'monitors' to be defined, subsequently allowing these 'monitors' to be notified of processing activities.
withMonitors(Monitors) - Method in class org.logicmachine.rebl.language.context.Scope: This method allows the given 'monitors' to be defined, subsequently allowing these 'monitors' to be notified of processing activities.
withNewState(Enum<?>) - Method in class org.logicmachine.rebl.domain.actions.StateTransitionAction: Allows the required state transition to be defined.
withObject(T) - Method in class org.logicmachine.rebl.common.ScopeAssignable: Allows the given object to be attached to the scope within this ScopeAssignable instance.
withObjects(List<T>) - Method in class org.logicmachine.rebl.common.ScopeAssignable: Allows a list of objects to be attached to the scope within this ScopeAssignable instance.
withObjects(Some<T>) - Method in class org.logicmachine.rebl.common.ScopeAssignable: Allows a set of objects to be attached to the scope within this ScopeAssignable instance.
withObjects(T...) - Method in class org.logicmachine.rebl.common.ScopeAssignable: Allows a set of objects to be attached to the scope within this ScopeAssignable instance.
withOutputStream(PrintStream) - Static method in class org.logicmachine.rebl.common.Common: Allows the system output stream to be reset to the given output stream.
withParallelActiveEntityForScope(ActiveEntity) - Static method in class org.logicmachine.rebl.common.Common: This method should be used to associate any ActiveEntity instances which are running in parallel with their corresponding Scope.
withParallelActiveEntityForScope(ActiveEntity) - Method in class org.logicmachine.rebl.language.Language: This method should be used to associate any ActiveEntity instances which are running in parallel with their corresponding Scope.
withParent() - Method in class org.logicmachine.rebl.language.context.Scope: Returns a handle to the parent scope of this instance, which can be a non-null 'empty' instance if this scope is the top-level scope.
withPredicate(Object) - Method in class org.logicmachine.rebl.domain.transactions.attributes.TransactionDetails: Setter method allowing a predicate to be set for a given operation.
withReason(Exception) - Method in class org.logicmachine.rebl.monitor.health.Health: Any health status can also (optionally) define a 'reason' for the current state.
withRepeatCount(int) - Method in class org.logicmachine.rebl.common.Repeatable: Setter method allowing the maximum number of repeat attempts to be defined.
withResource(Object) - Method in class org.logicmachine.rebl.domain.entities.ActiveEntity: This method forms a placeholder for the selection of a resource to participate in a transaction.
withResource(Object) - Method in class org.logicmachine.rebl.language.context.Scope: Once resources have been attached to the current scope, they can be accessed by key.
withResource(Object) - Method in interface org.logicmachine.rebl.language.details.Vocabulary: This method forms a placeholder for the selection of a resource to participate in a transaction.
withResource(XAResource) - Method in class org.logicmachine.rebl.domain.transactions.managers.AbstractTransactionAwareScope: Attempts to add the given XAresource to this scope.
withResource(XAResource) - Method in class org.logicmachine.rebl.domain.transactions.resources.TransactionResource: Defines the XAResource wrapped by this TransactionResource instance.
withResource(Resource) - Method in class org.logicmachine.rebl.language.context.Scope: Allows the given resource to be attached to the current scope.
withResource(TransactionResource) - Method in class org.logicmachine.rebl.domain.transactions.managers.AbstractTransactionAwareScope: Attempts to add the given TransactionResource to this scope.
withResource(TransactionResource) - Method in class org.logicmachine.rebl.domain.transactions.managers.JdbcTransactionAwareScope: Not supported by this implementation.
withResource(TransactionResource) - Method in class org.logicmachine.rebl.domain.transactions.managers.TransactionAwareScope: Attempts to add the given TransactionResource to this scope.
withResources(Resource...) - Method in class org.logicmachine.rebl.language.context.Scope: Allows the given resources to be attached to the current scope.
withResources(Resources) - Method in class org.logicmachine.rebl.language.context.Scope: Allows the given resources to be attached to the current scope.
withResults(Object) - Method in class org.logicmachine.rebl.domain.transactions.attributes.TransactionDetails: Stores the result of any queries associated with this transaction.
withResumeActions(T, Actions) - Method in class org.logicmachine.rebl.domain.stateMachines.StateMachine: Allows actions to be specified which will be triggered when resuming the given state from a super state.
withScope() - Method in class org.logicmachine.rebl.common.ScopeAssignable: Returns a handle to the scope associated with this ScopeAssignable instance.
withScope() - Method in class org.logicmachine.rebl.domain.resources.Resource
withScope(String) - Static method in class org.logicmachine.rebl.common.Common: Returns the scope associated with the given 'scopeName', or a non-null 'empty' scope instance on no match.
withScope(String) - Method in class org.logicmachine.rebl.language.context.Scope: Allows a new scope to be created with the given 'scopeName'.
withScope(String) - Method in class org.logicmachine.rebl.language.Language: Returns the scope associated with the given 'scopeName', or a non-null 'empty' scope instance on no match.
withScope(JdbcTransactionAwareScope) - Method in class org.logicmachine.rebl.domain.transactions.attributes.impl.TransactionActionImpl: This method allows a handle to a JdbsTransactionAwareScope instance to be defined, against which any subsequent actions will be invoked.
withScope(Scope) - Method in class org.logicmachine.rebl.common.ScopeAssignable: Creates a reference back to the enclosing scope associated with this instance.
withScope(Scope) - Method in class org.logicmachine.rebl.domain.entities.ActiveEntity
withScope(Scope) - Method in class org.logicmachine.rebl.domain.entities.Entity
withScope(Scope) - Method in class org.logicmachine.rebl.domain.resources.Resource
withScope(Scope) - Method in class org.logicmachine.rebl.domain.stateMachines.StateMachine
withScopedTransaction(ScopedTransaction) - Method in class org.logicmachine.rebl.domain.transactions.resources.TransactionResource: Stores the given 'scopedTransaction' provided this is not a duplicate entry, based on comparison of the associated 'Xid'.
withSleepTime(long) - Method in class org.logicmachine.rebl.common.Repeatable: Setter method allowing a sleep period to be defined, causing the processing to pause for the specified time period between successive iterations.
withSql(String) - Method in class org.logicmachine.rebl.domain.transactions.attributes.impl.TransactionActionImpl: This method allows SQL statements to be defined, which will subsequently be invoked against the underlying database.
withStateMachine() - Method in class org.logicmachine.rebl.domain.stateMachines.StateMachineExceptionHandler: Returns the underlying state machine which backs this exception handler.
withStateMachine(String) - Method in class org.logicmachine.rebl.domain.actions.StateTransitionAction: Defines the state machine instance to which this state transition should be applied.
withStateMachine(String) - Method in class org.logicmachine.rebl.domain.entities.ActiveEntity: Once state machines have been attached to the current scope, they can be accessed by name.
withStateMachine(String) - Method in class org.logicmachine.rebl.language.context.Scope: Once state machines have been attached to the current scope, they can be accessed by name.
withStateMachine(StateMachine<?>) - Method in class org.logicmachine.rebl.domain.entities.ActiveEntity: Allows the given state machine to be attached to the current scope.
withStateMachine(StateMachine<?>) - Method in class org.logicmachine.rebl.language.context.Scope: Allows the given state machine to be attached to the current scope.
withStateMachines() - Method in class org.logicmachine.rebl.language.context.Scope: Returns a list of the state machine instances which have been associated with this scope.
withStateMachines(StateMachine<?>...) - Method in class org.logicmachine.rebl.domain.entities.ActiveEntity: Allows the given state machines to be attached to the current scope.
withStateMachines(StateMachine<?>...) - Method in class org.logicmachine.rebl.language.context.Scope: Allows the given state machines to be attached to the current scope.
withStateMachines(StateMachines) - Method in class org.logicmachine.rebl.domain.entities.ActiveEntity: Allows the given state machines to be attached to the current scope.
withStateMachines(StateMachines) - Method in class org.logicmachine.rebl.language.context.Scope: Allows the given state machines to be attached to the current scope.
withSuperState(T) - Method in class org.logicmachine.rebl.domain.stateMachines.StateMachine: Adds the given 'superState' to the list of super states which are directly available from any other state without requiring explicit configuration of such state transition.
withSuspendActions(T, Actions) - Method in class org.logicmachine.rebl.domain.stateMachines.StateMachine: Allows actions to be specified which will be triggered when suspending the given state for a transition to a super state.
withThreadCompletionWaitTimeInMillis(long) - Method in class org.logicmachine.rebl.domain.entities.ActiveEntity: Defines the time to wait for the parallel thread to complete.
withThreadStartupSleepTimeInMillis(long) - Method in class org.logicmachine.rebl.domain.entities.ActiveEntity: Within the 'waitForCompletion()' method, this value defines the sleep time to wait for a parallel thread to start.
withTransitions(T, T...) - Method in class org.logicmachine.rebl.domain.stateMachines.StateMachine: Appends the given 'transitions' to the map of permitted state transitions.
withUndoActions() - Method in class org.logicmachine.rebl.common.Repeatable: Returns a list of operations to be performed as part of an undo operation, which will be triggered in the event of an error.
withUndoActions(Actions) - Method in class org.logicmachine.rebl.common.Repeatable: Allows a set of actions to be defined which will provide back-out support to undo an operation in the event of an error.
withValue(Object) - Method in class org.logicmachine.rebl.language.context.EnvironmentObject: Stores the given 'object' as the value of this KeyValue pair.
withValues(List<?>) - Method in class org.logicmachine.rebl.domain.transactions.attributes.impl.TransactionActionImpl: This method allows a list of value objects to be defined which will be used to replace any placeholders within the PreparedStatement.
withXid(Xid) - Method in class org.logicmachine.rebl.domain.transactions.attributes.TransactionDetails: Setter method allowing the transaction identifier to be set.

X

XA_FLAGS - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the label used within toString() methods to log the status flags associated with transactions within an XA resource.
XA_IN_FLIGHT - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the label used within toString() methods to log the in-flight transactions associated with an XA resource.
XA_IS_COMMIT - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the label used within toString() methods to log the isCommit flag associated with transactions within an XA resource.
XA_RESOURCE - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the label used within toString() methods to log the values associated with an XA resource.
XA_XIDS - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the label used within toString() methods to log the transaction id's associated with an XA resource.
XID_BRANCH_QUALIFIER - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the label used within toString() methods to log the branch qualifier of the XA transaction.
XID_FORMAT_ID - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the label used within toString() methods to log the format id of the XA transaction.
XID_FORMAT_IDENTIFIER - Static variable in class org.logicmachine.rebl.common.Constants: To ensure the uniqueness of our XA Transaction Xids we use this identifier, the start time and an incrementing AtomicLong.
XID_GLOBAL_TRANSACTION_ID - Static variable in class org.logicmachine.rebl.common.i18n.ExternalStrings: Holds the label used within toString() methods to log the global identifier of the XA transaction.
XidImpl - Class in org.logicmachine.rebl.domain.transactions.attributes.impl: Implements the XA 'Xid' interface, allowing unique global transaction Id's and unique branch qualifiers to be created.
XidImpl() - Constructor for class org.logicmachine.rebl.domain.transactions.attributes.impl.XidImpl: Default constructor.
XidImpl(byte[]) - Constructor for class org.logicmachine.rebl.domain.transactions.attributes.impl.XidImpl: Constructor creating a new Xid instance with the given 'globalTransactionId' and an automatically generated unique branch qualifier.
XidImpl(byte[], byte[]) - Constructor for class org.logicmachine.rebl.domain.transactions.attributes.impl.XidImpl: Constructor creating a new Xid instance with the given 'globalTransactionId' and 'branchQualifier'.

A B C D E F G H I J K L M N O P R S T U V W X
All Classes and Interfaces|All Packages|Constant Field Values|Serialized Form