java.lang.Object
- org.apache.jena.dboe.transaction.txn.TransactionalComponentLifecycle<X>

All Implemented Interfaces:

TransactionalComponent

Direct Known Subclasses:

TransactionalComponentBase, TransactionalComponentByLock, TransInteger
```
public abstract class TransactionalComponentLifecycle<X>
extends java.lang.Object
implements TransactionalComponent
```
Base implementation of the component interface for TransactionalComponent.

Nested Class Summary

Nested Classes
Modifier and Type Class Description

static class TransactionalComponentLifecycle.ComponentState<X>

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`abort(Transaction transaction)`	Abort a transaction (undo the effect of a transaction)
`void`	`attach(SysTransState state)`	Set the current thread to be in the transaction.
`void`	`begin(Transaction transaction)`	Start a transaction
`void`	`commit(Transaction transaction)`	Commit a transaction (make durable).
`void`	`commitEnd(Transaction transaction)`	Signal all commits on all components are done and replay from the journal will not happen.
`java.nio.ByteBuffer`	`commitPrepare(Transaction transaction)`	Commit a transaction (make durable): prepare - commit - cleanup
`void`	`complete(Transaction transaction)`	Finalization - the coordinator will not mention the transaction again.
`SysTransState`	`detach()`	Detach this component from the transaction of the current thread and return some internal state that can be used in a future call of `TransactionalComponent.attach(SysTransState)`
`abstract void`	`finishRecovery()`	End of the recovery phase
`ComponentId`	`getComponentId()`	Every component instance must supplied a unique number.
`TransactionalComponentLifecycle.ComponentState<X>`	`getComponentState()`
`boolean`	`promote(Transaction transaction)`	Promote a component in a transaction
`abstract void`	`recover(java.nio.ByteBuffer ref)`	Notification that `ref` was really committed and is being recovered.
`void`	`setComponentState(TransactionalComponentLifecycle.ComponentState<X> state)`
`void`	`shutdown()`	Shutdown component, aborting any in-progress transactions.
`abstract void`	`startRecovery()`

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

Methods inherited from interface org.apache.jena.dboe.transaction.txn.TransactionalComponent
cleanStart

- Method Detail
  - startRecovery
```
public abstract void startRecovery()
```
    Specified by:
    
    startRecovery in interface TransactionalComponent
  - recover
```
public abstract void recover(java.nio.ByteBuffer ref)
```
    Description copied from interface: TransactionalComponent
    
    Notification that ref was really committed and is being recovered.
    
    Specified by:
    
    recover in interface TransactionalComponent
    
    Parameters:
    
    ref - Same bytes as were written during prepare originally.
  - finishRecovery
```
public abstract void finishRecovery()
```
    Description copied from interface: TransactionalComponent
    
    End of the recovery phase
    
    Specified by:
    
    finishRecovery in interface TransactionalComponent
  - getComponentId
```
public ComponentId getComponentId()
```
    Description copied from interface: TransactionalComponent
    
    Every component instance must supplied a unique number. It is used to route journal entries to subsystems, including across restarts/recovery. Uniqueness scope is within the same TransactionCoordinator, and the same across restarts.
    If a component imposes the rule of one-per-TransactionCoordinator, the same number can be used (if different from all other component type instances).
    If a component can have multiple instances per TransactionCoordinator, for example indexes, each must have a unique instance id.
    
    Specified by:
    
    getComponentId in interface TransactionalComponent
  - begin
```
public final void begin(Transaction transaction)
```
    Start a transaction
    
    Specified by:
    
    begin in interface TransactionalComponent
  - promote
```
public final boolean promote(Transaction transaction)
```
    Promote a component in a transaction
    
    Specified by:
    
    promote in interface TransactionalComponent
  - commitPrepare
```
public final java.nio.ByteBuffer commitPrepare(Transaction transaction)
```
    Commit a transaction (make durable): prepare - commit - cleanup
    
    Specified by:
    
    commitPrepare in interface TransactionalComponent
  - commit
```
public final void commit(Transaction transaction)
```
    Description copied from interface: TransactionalComponent
    
    Commit a transaction (make durable). The transaction will commit and not abort. Other components may not have committed yet and recovery may occur still causing replay of the commit step.
    
    Specified by:
    
    commit in interface TransactionalComponent
  - commitEnd
```
public final void commitEnd(Transaction transaction)
```
    Description copied from interface: TransactionalComponent
    
    Signal all commits on all components are done and replay from the journal will not happen. The component can clear up now.
    
    Specified by:
    
    commitEnd in interface TransactionalComponent
  - abort
```
public final void abort(Transaction transaction)
```
    Description copied from interface: TransactionalComponent
    
    Abort a transaction (undo the effect of a transaction)
    
    Specified by:
    
    abort in interface TransactionalComponent
  - complete
```
public final void complete(Transaction transaction)
```
    Description copied from interface: TransactionalComponent
    
    Finalization - the coordinator will not mention the transaction again.
    
    Specified by:
    
    complete in interface TransactionalComponent
  - shutdown
```
public final void shutdown()
```
    Description copied from interface: TransactionalComponent
    
    Shutdown component, aborting any in-progress transactions. This operation is not guaranteed to be called.
    
    Specified by:
    
    shutdown in interface TransactionalComponent
  - detach
```
public final SysTransState detach()
```
    Description copied from interface: TransactionalComponent
    
    Detach this component from the transaction of the current thread and return some internal state that can be used in a future call of TransactionalComponent.attach(SysTransState)
    After this call, the component is not in a transaction but the existing transaction still exists. The thread may start a new transaction; that transaction is completely independent of the detached transaction.
    Returns null if the current thread not in a transaction. The component may return null to indicate it has no state. The return system state should be used in a call to TransactionalComponent.attach(SysTransState) and the transaction ended in the usual way.
    
    Specified by:
    
    detach in interface TransactionalComponent
  - attach
```
public void attach(SysTransState state)
```
    Description copied from interface: TransactionalComponent
    
    Set the current thread to be in the transaction. The systemState must be obtained from a call of TransactionalComponent.detach(). This method can only be called once per systemState.
    
    Specified by:
    
    attach in interface TransactionalComponent
  - getComponentState
```
public TransactionalComponentLifecycle.ComponentState<X> getComponentState()
```
  - setComponentState
```
public void setComponentState(TransactionalComponentLifecycle.ComponentState<X> state)
```

Class TransactionalComponentLifecycle<X>

Nested Class Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.apache.jena.dboe.transaction.txn.TransactionalComponent

Method Detail

startRecovery

recover

finishRecovery

getComponentId

begin

promote

commitPrepare

commit

commitEnd

abort

complete

shutdown

detach

attach

getComponentState

setComponentState