All Superinterfaces:

AutoCloseable, Closeable

All Known Implementing Classes:

DefaultTransaction
```
public interface Transaction
extends Closeable
```
The controller for Transaction with FeatureStore.
Shapefiles, databases, etc. are safely modified with the assistance of this interface. Transactions are also to provide authorization when working with locked features.
All operations are considered to be working against a Transaction. Transaction.AUTO_COMMIT is used to represent an immidiate mode where requests are immidately commited.
For more information please see DataStore and FeatureStore.
Example Use:
```
 Transaction t = new DefaultTransaction("handle");
 t.putProperty( "hint", Integer.valueOf(7) );
 try {
     SimpleFeatureStore road = (SimpleFeatureStore) store.getFeatureSource("road");
     FeatureStore river = (SimpleFeatureStore) store.getFeatureSource("river");

     road.setTransaction( t );
     river.setTransaction( t );

     t.addAuthorization( lockID );  // provide authoriztion
     road.removeFeatures( filter ); // operate against transaction
     river.removeFeature( filter ); // operate against transaction

     t.commit(); // commit operations
 }
 catch (IOException io){
     t.rollback(); // cancel operations
 }
 finally {
     t.close(); // free resources
 }
 
```
Example code walkthrough (from the perspective of Transaction):
1. A new transaction is created (an instanceof DefaultTransaction with a handle)
2. A hint is provided using Transaction.putProperty( key, value )
3. Transaction is provided to two FeatureStores, this may result in Transaction.State instances being registered
  - DiffTransactionState (stored by DataStore): Used for in memory locking by many DataStore's (like ShapefileDataStore). Lazy creation as part of ContentDataStore.getFeatureSource(Name typeName, Transaction tx).
  - JDBCTransactionState (stored by ConnectionPool): Used to manage connection rollback/commit. Lazy creation as part of JDBCDataStore.getConnection(transaction).
  - InProcessLockingManager.FeatureLock (stored by LockingManger): Used for per transaction FeatureLocks, used to free locked features on Transaction commit/rollback.
  These instances of Transaction state may make use of any hint provided to Transaction.putProperty( key, value ) when they are connected with Transaction.State.setTransaction( transaction ).
4. t.addAuthorization(lockID) is called, each Transaction.State has its addAuthroization(String) callback invoked with the value of lockID
5. FeatureStore.removeFeatures methods are called on the two DataStores.
  - PostgisFeatureStore.removeFeatures(filter) handles operation without delegation.
  - Most removeFeature(filter) implementations use the implementation provided by ContentFeatureStore which delegates to FeatureWriter.
  Any of these operations may make use of the Transaction.putProperty( key, value ).
6. The transaction is committed, all of the Transaction.State methods have there Transaction.State.commit() methods called giving them a chance to applyDiff maps, or commit various connections.
7. The transaction is closed, all of the Transaction.State methods have there Transaction.State.setTransaction( null ) called, giving them a chance to clean up diffMaps, or return connections to the pool.
Author:

Jody Garnett, Chris Holmes, TOPP

Nested Class Summary

Nested Classes
Modifier and Type	Interface	Description
`static interface`	`Transaction.State`	DataStore implementations can use this interface to externalize the state they require to implement Transaction Support.

Field Summary

Fields
Modifier and Type	Field	Description
`static Transaction`	`AUTO_COMMIT`	Represents AUTO_COMMIT mode as opposed to operations with commit/rollback control under a user-supplied transaction.

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method	Description
`void`	`addAuthorization(String authID)`	Provides an Authorization ID for this Transaction.
`void`	`close()`	Provides an opportunity for a Transaction to free an State it maintains.
`void`	`commit()`	Makes all transactions made since the previous commit/rollback permanent.
`Set<String>`	`getAuthorizations()`	List of Authorizations IDs held by this transaction.
`Object`	`getProperty(Object key)`	Retrive a Transaction property held by this transaction.
`Transaction.State`	`getState(Object key)`	Allows DataStores to squirel away information( and callbacks ) for later.
`void`	`putProperty(Object key, Object value)`	Provides a Transaction property for this Transasction.
`void`	`putState(Object key, Transaction.State state)`	Allows SimpleFeatureSource to squirel away information( and callbacks ) for later.
`void`	`removeState(Object key)`	Allows FeatureSources to clean up information ( and callbacks ) they earlier provided.
`void`	`rollback()`	Undoes all transactions made since the last commit or rollback.

- Field Detail
  - AUTO_COMMIT
```
static final Transaction AUTO_COMMIT
```
    Represents AUTO_COMMIT mode as opposed to operations with commit/rollback control under a user-supplied transaction.
- Method Detail
  - getProperty
```
Object getProperty(Object key)
```
    Retrive a Transaction property held by this transaction.
    This may be used to provide hints to DataStore implementations, it operates as a blackboard for client, SimpleFeatureSource communication.
  - getAuthorizations
```
Set<String> getAuthorizations()
```
    List of Authorizations IDs held by this transaction.
    This list is reset by the next call to commit() or rollback().
    Authorization IDs are used to provide FeatureLock support.
    
    Returns:
    
    List of Authorization IDs
  - putState
```
void putState(Object key,
              Transaction.State state)
```
    Allows SimpleFeatureSource to squirel away information( and callbacks ) for later.
    The most common example is a JDBC DataStore saving the required connection for later operations.
    ConnectionState implements State { public Connection conn; public addAuthorization() {} public commit(){ conn.commit(); } public rollback(){ conn.rollback(); } }
    
    putState will call State.setTransaction( transaction ) to allow State a chance to configure itself.
    Parameters:
    
    key - Key used to externalize State
    
    state - Externalized State
  - removeState
```
void removeState(Object key)
```
    Allows FeatureSources to clean up information ( and callbacks ) they earlier provided.
    Care should be taken when using shared State to not remove State required by another FeatureSources.
    removeState will call State.setTransaction( null ) to allow State a chance cleanup after itself.
    
    Parameters:
    
    key - Key that was used to externalize State
  - getState
```
Transaction.State getState(Object key)
```
    Allows DataStores to squirel away information( and callbacks ) for later.
    The most common example is a JDBC DataStore saving the required connection for later operations.
    
    Returns:
    
    Current State externalized by key, or null if not found
  - commit
```
void commit()
     throws IOException
```
    Makes all transactions made since the previous commit/rollback permanent.
    FeatureSources will need to issue any changes notifications using a FeatureEvent.FEATURES_CHANGED to all FeatureSources with the same typeName and a different Transaction. FeatureSources with the same Transaction will of been notified of changes as the FeaureWriter made them.
    
    Throws:
    
    DataSourceException - if there are any datasource errors.
    
    IOException
    
    See Also:
    
    #setAutoCommit(boolean)
  - rollback
```
void rollback()
       throws IOException
```
    Undoes all transactions made since the last commit or rollback.
    FeatureSources will need to issue any changes notifications using a FeatureEvent.FEATURES_CHANGED. This will need to be issued to all FeatureSources with the same typeName and Transaction.
    
    Throws:
    
    DataSourceException - if there are problems with the datasource.
    
    UnsupportedOperationException - if the rollback method is not supported by this datasource.
    
    IOException
    
    See Also:
    
    #setAutoCommit(boolean)
  - addAuthorization
```
void addAuthorization(String authID)
               throws IOException
```
    Provides an Authorization ID for this Transaction.
    All proceeding modifyFeatures,removeFeature, unLockFeatures, refreshLock and ReleaseLock operations will make use of the provided authorization.
    Authorization is only maintained until the this Transaction is commited or rolledback.
    That is operations will only succeed if affected features either:
    
    not locked
    locked with the provided authID
    
    Authorization ID is provided as a String, rather than a FeatureLock, to account for across process lock use.
    Throws:
    
    IOException
  - putProperty
```
void putProperty(Object key,
                 Object value)
          throws IOException
```
    Provides a Transaction property for this Transasction.
    All proceeding SimpleFeatureSource (for FeatureReader/Writer) operations may make use of the provided property.
    
    Throws:
    
    IOException
  - close
```
void close()
    throws IOException
```
    Provides an opportunity for a Transaction to free an State it maintains.
    This method should call State.setTransaction( null ) on all State it maintains.
    It is hoped that FeatureStore implementations that have externalized their State with the transaction take the opportunity to revert to Transction.AUTO_COMMIT.
    
    Specified by:
    
    close in interface AutoCloseable
    
    Specified by:
    
    close in interface Closeable
    
    Throws:
    
    IOException

Interface Transaction

Nested Class Summary

Field Summary

Method Summary

Field Detail

AUTO_COMMIT

Method Detail

getProperty

getAuthorizations

putState

removeState

getState

commit

rollback

addAuthorization

putProperty

close