CurrentImple (Narayana: all 5.0.0.Final API)

java.lang.Object
- org.omg.CORBA.LocalObject
- - com.arjuna.ats.internal.jts.orbspecific.CurrentImple

All Implemented Interfaces:

Current, Serializable, CurrentOperations, Object, IDLEntity
```
public class CurrentImple
extends LocalObject
implements Current, Current
```
The implementation of CosTransactions::Current. In a multi-threaded environment where threads can terminate transactions they may not have started, then it is possible for a thread to call commit/rollback/rollback_only on a transaction which has already been (or is in the process of being) terminated. We assume that the subsequent thread is still associated with the transaction so that it can determine its status, rather than simply disassociate it when it tries to terminate and return NoTransaction, so we would return INVALID_TRANSACTION. This allows us to distinguish between the situation where there really is no transaction associated with the thread.

Since:

JTS 1.0.

Version:

$Id: CurrentImple.java 2342 2006-03-30 13:06:17Z $

Author:

Mark Little (mark@arjuna.com)

See Also:

Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`protected static ContextManager`	`_theManager`
`static int`	`TX_ABORTED`
`static int`	`TX_BEGUN`
`static int`	`TX_COMMITTED`
`static int`	`TX_RESUMED`
`static int`	`TX_SUSPENDED`

Constructor Summary

Constructors
Constructor and Description

CurrentImple()

Constructors
Constructor and Description
`CurrentImple()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`begin()`
`void`	`commit(boolean report_heuristics)` It's not possible to commit/abort out of order using the current interface.
`ContextManager`	`contextManager()` Returns the internal context manager implementation.
`Control`	`get_control()`
`Status`	`get_status()`
`int`	`get_timeout()`
`String`	`get_transaction_name()`
`CheckedAction`	`getCheckedAction()`
`ControlWrapper`	`getControlWrapper()`
`void`	`resume(Control which)` To support checked transactions we can only resume if the action is local or we received it implicitly.
`void`	`resumeImple(ControlImple which)`
`void`	`resumeWrapper(ControlWrapper which)`
`void`	`rollback_only()` If the transaction has already terminated (or is being terminated) then throw INVALID_TRANSACTION.
`void`	`rollback()` If another thread has already terminated the transaction then: (i) if it rolled back, we do nothing - could throw TransactionRequired of INVALID_TRANSACTION, or NoTransaction.
`void`	`set_timeout(int seconds)`
`void`	`setCheckedAction(CheckedAction ca)`
`Control`	`suspend()` The spec.
`ControlWrapper`	`suspendWrapper()`

Methods inherited from class org.omg.CORBA.LocalObject
_create_request, _create_request, _duplicate, _get_domain_managers, _get_interface_def, _get_interface, _get_policy, _hash, _invoke, _is_a, _is_equivalent, _is_local, _non_existent, _orb, _release, _releaseReply, _request, _request, _servant_postinvoke, _servant_preinvoke, _set_policy_override, validate_connection

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.omg.CORBA.Object
_create_request, _create_request, _duplicate, _get_domain_managers, _get_interface_def, _get_policy, _hash, _is_a, _is_equivalent, _non_existent, _release, _request, _set_policy_override

- Field Detail
  - TX_BEGUN
```
public static final int TX_BEGUN
```
    See Also:
    
    Constant Field Values
  - TX_COMMITTED
```
public static final int TX_COMMITTED
```
    See Also:
    
    Constant Field Values
  - TX_ABORTED
```
public static final int TX_ABORTED
```
    See Also:
    
    Constant Field Values
  - TX_SUSPENDED
```
public static final int TX_SUSPENDED
```
    See Also:
    
    Constant Field Values
  - TX_RESUMED
```
public static final int TX_RESUMED
```
    See Also:
    
    Constant Field Values
  - _theManager
```
protected static ContextManager _theManager
```
- Constructor Detail
  - CurrentImple
```
public CurrentImple()
```
- Method Detail
  - begin
```
public void begin()
           throws SubtransactionsUnavailable,
                  SystemException
```
    Throws:
    
    SubtransactionsUnavailable
    
    SystemException
  - commit
```
public void commit(boolean report_heuristics)
            throws NoTransaction,
                   HeuristicMixed,
                   HeuristicHazard,
                   SystemException
```
    It's not possible to commit/abort out of order using the current interface. Do we delete the control if the transaction gives an heuristic result? CurrentImplely we do. If another thread has already terminated the transaction then: (i) if it committed, we do nothing - could throw TransactionRequired of INVALID_TRANSACTION, or NoTransaction. Probably not NoTransaction, since it would be better to distinguish between the situation where the transaction has already been terminated and there really is no transaction for this thread. (ii) if it rolledback, we throw TRANSACTION_ROLLEDBACK.
    
    Throws:
    
    NoTransaction
    
    HeuristicMixed
    
    HeuristicHazard
    
    SystemException
  - rollback
```
public void rollback()
              throws NoTransaction,
                     SystemException
```
    If another thread has already terminated the transaction then: (i) if it rolled back, we do nothing - could throw TransactionRequired of INVALID_TRANSACTION, or NoTransaction. Probably not NoTransaction, since it would be better to distinguish between the situation where the transaction has already been terminated and there really is no transaction for this thread. (ii) if it committed, we throw INVALID_TRANSACTION.
    
    Throws:
    
    NoTransaction
    
    SystemException
  - rollback_only
```
public void rollback_only()
                   throws NoTransaction,
                          SystemException
```
    If the transaction has already terminated (or is being terminated) then throw INVALID_TRANSACTION.
    
    Throws:
    
    NoTransaction
    
    SystemException
  - get_status
```
public Status get_status()
                  throws SystemException
```
    Throws:
    
    SystemException
  - get_transaction_name
```
public String get_transaction_name()
                            throws SystemException
```
    Throws:
    
    SystemException
  - set_timeout
```
public void set_timeout(int seconds)
                 throws SystemException
```
    Throws:
    
    SystemException
  - get_timeout
```
public final int get_timeout()
                      throws SystemException
```
    Throws:
    
    SystemException
  - setCheckedAction
```
public void setCheckedAction(CheckedAction ca)
                      throws SystemException
```
    Specified by:
    
    setCheckedAction in interface Current
    
    Throws:
    
    SystemException
  - getCheckedAction
```
public CheckedAction getCheckedAction()
                               throws SystemException
```
    Specified by:
    
    getCheckedAction in interface Current
    
    Throws:
    
    SystemException
  - get_control
```
public Control get_control()
                    throws SystemException
```
    Throws:
    
    SystemException
  - suspend
```
public Control suspend()
                throws SystemException
```
    The spec. states that after suspend we should have a null transaction context, but is hazy as to what to do if we are nested. We shall assume that the control returned is for the current transaction and that we suspend the entire transaction hierarchy. Given the returned control, we can always regenerate the hierarchy later if required by resume.
    
    Throws:
    
    SystemException
  - resume
```
public void resume(Control which)
            throws InvalidControl,
                   SystemException
```
    To support checked transactions we can only resume if the action is local or we received it implicitly. If the control refers to a nested transaction then we must recreate the entire hierarchy, i.e., the effect of a suspend/resume on the same control should be the same as never calling suspend in the first place. If the control is for a local transaction then it is simple to recreate the hierarchy. Otherwise we rely upon the PropagationContext to recreate it. If this control is a "proxy" then create a new proxy instance, so we can delete proxies whenever suspend is called. Should check if "new" transaction is not actually the current one anyway. If so, just return. The spec. doesn't mention what to do in this case, so for now we go to the overhead of the work regardless.
    
    Throws:
    
    InvalidControl
    
    SystemException
  - contextManager
```
public final ContextManager contextManager()
```
    Returns the internal context manager implementation. Applications should not use this method.
    
    Since:
    
    JTS 2.1.
  - resumeImple
```
public void resumeImple(ControlImple which)
                 throws InvalidControl,
                        SystemException
```
    Throws:
    
    InvalidControl
    
    SystemException
  - resumeWrapper
```
public void resumeWrapper(ControlWrapper which)
                   throws InvalidControl,
                          SystemException
```
    Throws:
    
    InvalidControl
    
    SystemException
  - suspendWrapper
```
public ControlWrapper suspendWrapper()
                              throws SystemException
```
    Throws:
    
    SystemException
  - getControlWrapper
```
public ControlWrapper getControlWrapper()
                                 throws SystemException
```
    Throws:
    
    SystemException

Class CurrentImple

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.omg.CORBA.LocalObject

Methods inherited from class java.lang.Object

Methods inherited from interface org.omg.CORBA.Object

Field Detail

TX_BEGUN

TX_COMMITTED

TX_ABORTED

TX_SUSPENDED

TX_RESUMED

_theManager

Constructor Detail

CurrentImple

Method Detail

begin

commit

rollback

rollback_only

get_status

get_transaction_name

set_timeout

get_timeout

setCheckedAction

getCheckedAction

get_control

suspend

resume

contextManager

resumeImple

resumeWrapper

suspendWrapper

getControlWrapper