FederatedMode (n-orm core 0.0.1-SNAPSHOT API)

java.lang.Object
- java.lang.Enum<FederatedMode>
- - com.googlecode.n_orm.FederatedMode

All Implemented Interfaces:

Serializable, Comparable<FederatedMode>
```
public enum FederatedMode
extends Enum<FederatedMode>
```
The different consistency possibilities for a table to be federated.
Consistency, for federated tables, consists in avoiding having duplicated rows within two different tables. This can happen depending whether result for the postfix computation (as given by PersistingElementOverFederatedTable.getTablePostfix()) keep constant with time, that is it always returns the same value for a given persisting element.

Three solutions are proposed to check for consistency:
- Throwing an IllegalStateException when postfix computation changes over time (computation consistency)
- Check existence of identifier for an element in all table alternatives before reading it from data store ; this way, actual table postfix is searched in the data store in preference of calling PersistingElementOverFederatedTable.getTablePostfix() on read operations
- Check existence of identifier for an element in all table alternatives before writing it to data store ; this way, actual table postfix is searched in the data store in preference of calling PersistingElementOverFederatedTable.getTablePostfix() on write operations
Full consistency, be it for read or write, consists in checking existence of the element's identifier in alternative tables. All alternative tables are queried for the existence of the identifier (using Store.exists(com.googlecode.n_orm.storeapi.MetaInformation, String, String)). Tables are queried in sequence in probability order:
1. table with computed postfix
2. table with no postfix (a.k.a. original table, i.e. the table in which the element would be located in case it is not using federated tables)
3. alternative tables already known
4. all alternative tables found from the data store as they are saved in a special meta table
Achieving full consistency obviously requires a multiple queries on the data store just for sake of checks. To reduce number of checks, it is possible to restrict consistency checks to the original table, i.e. ignore tables of points 3 and 4. This mode is called "consistency with legacy" as it keeps the table federation consistent when a persisting class is changed from not federated to federated.

Enumerated values are named using the following general pattern:
1. PC when computed postfix should not change over time
2. RCONS (read consistency) or RLEG (read legacy consistency) when read operations trigger consistency checks to determine actual postfix before any read operation (like PersistingElement.activate(String...) or PersistingElement.existsInStore())
3. WCONS (write consistency) or WLEG (write legacy consistency) when read operations trigger consistency checks to determine actual postfix before any read operation (like PersistingElement.store())
When read and write operation should the the same level of consistency checks, only consistency level is indicated. Note that PersistingElement.delete() uses the most consistent mode between read and write consistency.
See Also:

FederatedTableManagement for more implementation details

Enum Constant Summary

Enum Constants
Enum Constant and Description
`CONS` Find from the datastore actual table for elements prior to any read or write operation before calling `PersistingElementOverFederatedTable.getTablePostfix()`.
`INCONS` Table for elements is postfixed by result of `PersistingElementOverFederatedTable.getTablePostfix()`.
`LEG` Finds from the datastore whether table for this element is the original table or table postfixed with `PersistingElementOverFederatedTable.getTablePostfix()` prior to any read or write operation.
`NONE` A single table (the original table) is to be used for storing elements.
`PC_CONS` Find from the datastore actual table for elements prior to any read or write operation before calling `PersistingElementOverFederatedTable.getTablePostfix()`.
`PC_INCONS` Table for elements is postfixed by result of `PersistingElementOverFederatedTable.getTablePostfix()`.
`PC_LEG` Finds from the datastore whether table for this element is the original table or table postfixed with `PersistingElementOverFederatedTable.getTablePostfix()` prior to any write operation.
`PC_RCONS` Find from the datastore actual table for elements prior to any read operation before calling `PersistingElementOverFederatedTable.getTablePostfix()`.
`PC_RCONS_WLEG` Finds from the datastore whether table for this element is the original table or table postfixed with `PersistingElementOverFederatedTable.getTablePostfix()` prior to any read operation.
`PC_RLEG` Finds from the datastore whether table for this element is the original table or table postfixed with `PersistingElementOverFederatedTable.getTablePostfix()` prior to any read operation.
`PC_RLEG_WCONS` Find from the datastore actual table for elements prior to any write operation before calling `PersistingElementOverFederatedTable.getTablePostfix()`.
`PC_WCONS` Find from the datastore actual table for elements prior to any write operation before calling `PersistingElementOverFederatedTable.getTablePostfix()`.
`PC_WLEG` Finds from the datastore whether table for this element is the original table or table postfixed with `PersistingElementOverFederatedTable.getTablePostfix()` prior to any write operation.
`RCONS` Find from the datastore actual table for elements prior to any read operation before calling `PersistingElementOverFederatedTable.getTablePostfix()`.
`RCONS_WLEG` Finds from the datastore whether table for this element is the original table or table postfixed with `PersistingElementOverFederatedTable.getTablePostfix()` prior to any read operation.
`RLEG` Finds from the datastore whether table for this element is the original table or table postfixed with `PersistingElementOverFederatedTable.getTablePostfix()` prior to any read operation.
`RLEG_WCONS` Find from the datastore actual table for elements prior to any write operation before calling `PersistingElementOverFederatedTable.getTablePostfix()`.
`WCONS` Find from the datastore actual table for elements prior to any write operation before calling `PersistingElementOverFederatedTable.getTablePostfix()`.
`WLEG` Finds from the datastore whether table for this element is the original table or table postfixed with `PersistingElementOverFederatedTable.getTablePostfix()` prior to any write operation.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Consistency`	`getConsistency(ReadWrite mode)`
`boolean`	`isCheckForChangingPostfix()` Whether elements of this persisting class should be checked for coherent results for `PersistingElementOverFederatedTable.getTablePostfix()`
`boolean`	`isFederated()` Whether elements of this persisting class might be stored in another able than that one stated by `PersistingMixin.getTable(Class)`
`static FederatedMode`	`valueOf(String name)` Returns the enum constant of this type with the specified name.
`static FederatedMode[]`	`values()` Returns an array containing the constants of this enum type, in the order they are declared.

Methods inherited from class java.lang.Enum
clone, compareTo, equals, finalize, getDeclaringClass, hashCode, name, ordinal, toString, valueOf

Methods inherited from class java.lang.Object
getClass, notify, notifyAll, wait, wait, wait

- Enum Constant Detail
  - NONE
```
public static final FederatedMode NONE
```
    A single table (the original table) is to be used for storing elements.
  - INCONS
```
public static final FederatedMode INCONS
```
    Table for elements is postfixed by result of PersistingElementOverFederatedTable.getTablePostfix(). This can be dangerous if the latter result changes over time for a given element as an element can appear in different tables and only one table will be used for operations.
  - PC_INCONS
```
public static final FederatedMode PC_INCONS
```
    Table for elements is postfixed by result of PersistingElementOverFederatedTable.getTablePostfix(). Result for the latter operation are regularly checked not to change over time.
  - RLEG
```
public static final FederatedMode RLEG
```
    Finds from the datastore whether table for this element is the original table or table postfixed with PersistingElementOverFederatedTable.getTablePostfix() prior to any read operation.
  - PC_RLEG
```
public static final FederatedMode PC_RLEG
```
    Finds from the datastore whether table for this element is the original table or table postfixed with PersistingElementOverFederatedTable.getTablePostfix() prior to any read operation. Result for PersistingElementOverFederatedTable.getTablePostfix() is regularly checked to be consistent in case table is postfixed.
  - RCONS
```
public static final FederatedMode RCONS
```
    Find from the datastore actual table for elements prior to any read operation before calling PersistingElementOverFederatedTable.getTablePostfix().
  - PC_RCONS
```
public static final FederatedMode PC_RCONS
```
    Find from the datastore actual table for elements prior to any read operation before calling PersistingElementOverFederatedTable.getTablePostfix(). Result for PersistingElementOverFederatedTable.getTablePostfix() is regularly checked to be consistent in case table is postfixed.
  - WLEG
```
public static final FederatedMode WLEG
```
    Finds from the datastore whether table for this element is the original table or table postfixed with PersistingElementOverFederatedTable.getTablePostfix() prior to any write operation.
  - PC_WLEG
```
public static final FederatedMode PC_WLEG
```
    Finds from the datastore whether table for this element is the original table or table postfixed with PersistingElementOverFederatedTable.getTablePostfix() prior to any write operation. Result for PersistingElementOverFederatedTable.getTablePostfix() is regularly checked to be consistent in case table is postfixed.
  - LEG
```
public static final FederatedMode LEG
```
    Finds from the datastore whether table for this element is the original table or table postfixed with PersistingElementOverFederatedTable.getTablePostfix() prior to any read or write operation.
  - PC_LEG
```
public static final FederatedMode PC_LEG
```
    Finds from the datastore whether table for this element is the original table or table postfixed with PersistingElementOverFederatedTable.getTablePostfix() prior to any write operation. Result for PersistingElementOverFederatedTable.getTablePostfix() is regularly checked to be consistent in case table is postfixed.
  - RCONS_WLEG
```
public static final FederatedMode RCONS_WLEG
```
    Finds from the datastore whether table for this element is the original table or table postfixed with PersistingElementOverFederatedTable.getTablePostfix() prior to any read operation. Regarding write operation, only table with no postfix is checked.
  - PC_RCONS_WLEG
```
public static final FederatedMode PC_RCONS_WLEG
```
    Finds from the datastore whether table for this element is the original table or table postfixed with PersistingElementOverFederatedTable.getTablePostfix() prior to any read operation. Regarding write operation, only table with no postfix is checked. Result for PersistingElementOverFederatedTable.getTablePostfix() is regularly checked to be consistent in case table is postfixed.
  - WCONS
```
public static final FederatedMode WCONS
```
    Find from the datastore actual table for elements prior to any write operation before calling PersistingElementOverFederatedTable.getTablePostfix().
  - PC_WCONS
```
public static final FederatedMode PC_WCONS
```
    Find from the datastore actual table for elements prior to any write operation before calling PersistingElementOverFederatedTable.getTablePostfix(). Result for PersistingElementOverFederatedTable.getTablePostfix() is regularly checked to be consistent in case table is postfixed.
  - RLEG_WCONS
```
public static final FederatedMode RLEG_WCONS
```
    Find from the datastore actual table for elements prior to any write operation before calling PersistingElementOverFederatedTable.getTablePostfix(). Regarding read operation, only table with no postfix is checked.
  - PC_RLEG_WCONS
```
public static final FederatedMode PC_RLEG_WCONS
```
    Find from the datastore actual table for elements prior to any write operation before calling PersistingElementOverFederatedTable.getTablePostfix(). Regarding read operation, only table with no postfix is checked. Result for PersistingElementOverFederatedTable.getTablePostfix() is regularly checked to be consistent in case table is postfixed.
  - CONS
```
public static final FederatedMode CONS
```
    Find from the datastore actual table for elements prior to any read or write operation before calling PersistingElementOverFederatedTable.getTablePostfix().
  - PC_CONS
```
public static final FederatedMode PC_CONS
```
    Find from the datastore actual table for elements prior to any read or write operation before calling PersistingElementOverFederatedTable.getTablePostfix(). Result for PersistingElementOverFederatedTable.getTablePostfix() is regularly checked to be consistent in case table is postfixed.
- Method Detail
  - values
```
public static FederatedMode[] values()
```
    Returns an array containing the constants of this enum type, in the order they are declared. This method may be used to iterate over the constants as follows:
```
for (FederatedMode c : FederatedMode.values())
    System.out.println(c);
```
    Returns:
    
    an array containing the constants of this enum type, in the order they are declared
  - valueOf
```
public static FederatedMode valueOf(String name)
```
    Returns the enum constant of this type with the specified name. The string must match exactly an identifier used to declare an enum constant in this type. (Extraneous whitespace characters are not permitted.)
    
    Parameters:
    
    name - the name of the enum constant to be returned.
    
    Returns:
    
    the enum constant with the specified name
    
    Throws:
    
    IllegalArgumentException - if this enum type has no constant with the specified name
    
    NullPointerException - if the argument is null
  - isFederated
```
public boolean isFederated()
```
    Whether elements of this persisting class might be stored in another able than that one stated by PersistingMixin.getTable(Class)
  - isCheckForChangingPostfix
```
public boolean isCheckForChangingPostfix()
```
    Whether elements of this persisting class should be checked for coherent results for PersistingElementOverFederatedTable.getTablePostfix()
  - getConsistency
```
public Consistency getConsistency(ReadWrite mode)
```

Enum FederatedMode

Enum Constant Summary

Method Summary

Methods inherited from class java.lang.Enum

Methods inherited from class java.lang.Object

Enum Constant Detail

NONE

INCONS

PC_INCONS

RLEG

PC_RLEG

RCONS

PC_RCONS

WLEG

PC_WLEG

LEG

PC_LEG

RCONS_WLEG

PC_RCONS_WLEG

WCONS

PC_WCONS

RLEG_WCONS

PC_RLEG_WCONS

CONS

PC_CONS

Method Detail

values

valueOf

isFederated

isCheckForChangingPostfix

getConsistency