InternalXAVersionManager (Apache Jackrabbit 2.18.6 API)

java.lang.Object
- org.apache.jackrabbit.core.version.InternalXAVersionManager

All Implemented Interfaces:

EventStateCollectionFactory, ItemStateManager, InternalVersionManager, VirtualItemStateProvider, InternalXAResource
```
public class InternalXAVersionManager
extends Object
implements EventStateCollectionFactory, VirtualItemStateProvider, InternalXAResource
```
Implementation of a InternalVersionManager that works in an XA environment. Works as a filter between a version manager client and the global version manager.

Field Summary

Fields
Modifier and Type	Field and Description
`protected NodeId`	`activitiesId`
`protected NodeId`	`historiesId`
`protected NodeTypeRegistry`	`ntReg` Node type registry.
`protected LocalItemStateManager`	`stateMgr` State manager for the version storage.

Constructor Summary

Constructors
Constructor and Description
`InternalXAVersionManager(InternalVersionManagerImpl vMgr, NodeTypeRegistry ntReg, SessionImpl session, ItemStateCacheFactory cacheFactory)` Creates a new instance of this class.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`VersioningLock.ReadLock`	`acquireReadLock()` acquires the read lock on this version manager.
`protected VersioningLock.WriteLock`	`acquireWriteLock()` Acquires the write lock on this version manager.
`void`	`addListener(ItemStateListener listener)` Add an `ItemStateListener`
`void`	`afterOperation(TransactionContext tx)` Invoked after one of the `InternalXAResource.prepare(org.apache.jackrabbit.data.core.TransactionContext)`, `InternalXAResource.commit(org.apache.jackrabbit.data.core.TransactionContext)` or `InternalXAResource.rollback(org.apache.jackrabbit.data.core.TransactionContext)` method has been called.
`void`	`associate(TransactionContext tx)` Associate this resource with a transaction.
`void`	`beforeOperation(TransactionContext tx)` Invoked before one of the `InternalXAResource.prepare(org.apache.jackrabbit.data.core.TransactionContext)`, `InternalXAResource.commit(org.apache.jackrabbit.data.core.TransactionContext)` or `InternalXAResource.rollback(org.apache.jackrabbit.data.core.TransactionContext)` method is called.
`protected String`	`calculateCheckinVersionName(org.apache.jackrabbit.core.version.InternalVersionHistoryImpl history, NodeStateEx node, boolean simple)` Calculates the name of the new version that will be created by a checkin call.
`NodeId`	`canCheckout(NodeStateEx state, NodeId activityId)` invokes the checkout() on the persistent version manager.
`protected InternalVersion`	`checkin(NodeStateEx node, Calendar created)` Creates a new version of the given node using the given version creation time.
`InternalVersion`	`checkin(Session session, NodeStateEx node, Calendar created)` invokes the checkin() on the persistent version manager and remaps the newly created version objects.
`void`	`close()` Close this version manager.
`void`	`commit(TransactionContext tx)` Commit transaction.
`NodeId`	`createActivity(Session session, String title)` Creates a new activity
`EventStateCollection`	`createEventStateCollection()` Creates an `EventStateCollection`.
`protected InternalVersionItem`	`createInternalVersionItem(NodeId id)` Creates an `InternalVersionItem` based on the `NodeState` identified by `id`.
`VirtualNodeState`	`createNodeState(VirtualNodeState parent, Name name, NodeId id, Name nodeTypeName)` Creates a new virtual node state
`VirtualPropertyState`	`createPropertyState(VirtualNodeState parent, Name name, int type, boolean multiValued)` Creats a new virtual property state
`protected VersionHistoryInfo`	`createVersionHistory(Session session, NodeState node, NodeId copiedFrom)` Creates a new version history.
`protected NodeStateEx`	`getActivitiesRoot()` returns the id of the activities root node
`InternalActivity`	`getActivity(NodeId id)` Returns the activity with the given id
`InternalBaseline`	`getBaseline(NodeId id)` Returns the baseline with the given id
`InternalVersion`	`getHeadVersionOfNode(NodeId id)` Returns the head version of the node with the given id.
`protected NodeStateEx`	`getHistoryRoot()` returns the id of the version history root node
`protected InternalVersionItem`	`getItem(NodeId id)` Returns the item with the given persistent id.
`ItemState`	`getItemState(ItemId id)` Return an item state, given its item id.
`protected static Name`	`getName(String name)` Utility method that returns the given string as a name in the default namespace.
`NodeIdFactory`	`getNodeIdFactory()`
`NodeReferences`	`getNodeReferences(NodeId id)` Return a node references object, given its target id
`protected NodeStateEx`	`getNodeStateEx(NodeId parentNodeId)` Returns the node with the given persistent id.
`protected static NodeStateEx`	`getParentNode(NodeStateEx parent, String uuid, Name interNT)` Utility method that returns the parent node under which the version history of the identified versionable node is or will be stored.
`InternalVersion`	`getVersion(NodeId id)` Returns the version with the given id
`InternalVersionHistory`	`getVersionHistory(NodeId id)` Returns the version history with the given id
`VersionHistoryInfo`	`getVersionHistory(Session session, NodeState node, NodeId copiedFrom)` Returns information about the version history of the specified node.
`VersionHistoryInfo`	`getVersionHistoryInfoForNode(NodeState node)` Returns information about the version history of the specified node or `null` when unavailable.
`InternalVersionHistory`	`getVersionHistoryOfNode(NodeId id)` Returns the version history for the versionable node with the given id.
`VirtualItemStateProvider`	`getVirtualItemStateProvider()` returns the virtual item state provider that exposes the internal versions as items.
`NodeId`	`getVirtualRootId()` Returns the id of the root node of the virtual tree.
`NodeId[]`	`getVirtualRootIds()` Returns the ids of the root nodes of the virtual tree.
`InternalXAResource`	`getXAResourceBegin()` Returns an `InternalXAResource` that acquires a write lock on the version manager in `InternalXAResource.prepare(TransactionContext)`.
`InternalXAResource`	`getXAResourceEnd()` Returns an `InternalXAResource` that releases the write lock on the version manager in `InternalXAResource.commit(TransactionContext)` or `InternalXAResource.rollback(TransactionContext)`.
`protected boolean`	`hasItem(NodeId id)` Return a flag indicating if the item specified exists.
`protected boolean`	`hasItemReferences(NodeId id)` Checks if there are item references (from outside the version storage) that reference the given node.
`boolean`	`hasItemState(ItemId id)` Return a flag indicating whether an item state for a given item id exists.
`boolean`	`hasNodeReferences(NodeId id)` Return a flag indicating whether a node references object for a given target id exists.
`protected InternalVersion`	`internalCheckin(org.apache.jackrabbit.core.version.InternalVersionHistoryImpl history, NodeStateEx node, boolean simple, Calendar created)` Checks in a node
`protected void`	`internalRemoveActivity(org.apache.jackrabbit.core.version.InternalActivityImpl activity)` Removes the specified activity
`protected void`	`internalRemoveVersion(org.apache.jackrabbit.core.version.InternalVersionHistoryImpl history, Name name)` Removes the specified version from the history
`void`	`internalRemoveVersionHistory(org.apache.jackrabbit.core.version.InternalVersionHistoryImpl history)` Removes the specified history from the storage
`boolean`	`isVirtualRoot(ItemId id)` Checks if the id refers to the root of a virtual tree.
`protected void`	`itemDiscarded(InternalVersionItem item)` Invoked by the internal version item itself, when it's underlying persistence state was discarded.
`void`	`prepare(TransactionContext tx)` Prepare transaction.
`void`	`removeActivity(Session session, NodeId nodeId)` Removes an activity and all
`void`	`removeListener(ItemStateListener listener)` Remove an `ItemStateListener`
`void`	`removeVersion(Session session, InternalVersionHistory history, Name versionName)` Removes the specified version from the given version history.
`void`	`removeVersionHistory(Session session, InternalVersionHistory history)` Removes the specified version history from storage.
`void`	`rollback(TransactionContext tx)` Rollback transaction.
`boolean`	`setNodeReferences(ChangeLog references)` Informs this provider that the node references to some of its states have changed.
`protected InternalVersion`	`setVersionLabel(org.apache.jackrabbit.core.version.InternalVersionHistoryImpl history, Name version, Name label, boolean move)` Set version label on the specified version.
`InternalVersion`	`setVersionLabel(Session session, InternalVersionHistory history, Name version, Name label, boolean move)` Sets the version `label` to the given `version`.
`protected void`	`versionCreated(InternalVersion version)` Invoked when a new internal item has been created.
`protected void`	`versionDestroyed(InternalVersion version)` Invoked when a new internal item has been destroyed.

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

- Field Detail
  - stateMgr
```
protected LocalItemStateManager stateMgr
```
    State manager for the version storage.
  - ntReg
```
protected final NodeTypeRegistry ntReg
```
    Node type registry.
  - historiesId
```
protected final NodeId historiesId
```
  - activitiesId
```
protected final NodeId activitiesId
```
- Constructor Detail
  - InternalXAVersionManager
```
public InternalXAVersionManager(InternalVersionManagerImpl vMgr,
                                NodeTypeRegistry ntReg,
                                SessionImpl session,
                                ItemStateCacheFactory cacheFactory)
                         throws RepositoryException
```
    Creates a new instance of this class.
    
    Parameters:
    
    vMgr - the underlying version manager
    
    ntReg - node type registry
    
    session - the session
    
    cacheFactory - cache factory
    
    Throws:
    
    RepositoryException - if a an error occurs
- Method Detail
  - createEventStateCollection
```
public EventStateCollection createEventStateCollection()
                                                throws RepositoryException
```
    Creates an EventStateCollection.
    
    Specified by:
    
    createEventStateCollection in interface EventStateCollectionFactory
    
    Returns:
    
    a new EventStateCollection
    
    Throws:
    
    RepositoryException - if creation fails for some reason
  - getVirtualItemStateProvider
```
public VirtualItemStateProvider getVirtualItemStateProvider()
```
    returns the virtual item state provider that exposes the internal versions as items.
    
    Specified by:
    
    getVirtualItemStateProvider in interface InternalVersionManager
    
    Returns:
    
    the virtual item state provider.
  - createVersionHistory
```
protected VersionHistoryInfo createVersionHistory(Session session,
                                                  NodeState node,
                                                  NodeId copiedFrom)
                                           throws RepositoryException
```
    Creates a new version history. This action is needed either when creating a new 'mix:versionable' node or when adding the 'mix:versionable' mixin to a node.
    
    Parameters:
    
    session - repository session
    
    node - versionable node state
    
    copiedFrom - node id for the jcr:copiedFrom property
    
    Returns:
    
    identifier of the new version history node
    
    Throws:
    
    RepositoryException - if an error occurs
    
    See Also:
    
    getVersionHistory(Session, NodeState, NodeId)
  - createActivity
```
public NodeId createActivity(Session session,
                             String title)
                      throws RepositoryException
```
    Creates a new activity
    
    Specified by:
    
    createActivity in interface InternalVersionManager
    
    Parameters:
    
    session - the current session
    
    title - title of the new activity
    
    Returns:
    
    the nodeid of the new activity
    
    Throws:
    
    RepositoryException - if an error occurs
  - removeActivity
```
public void removeActivity(Session session,
                           NodeId nodeId)
                    throws RepositoryException
```
    Removes an activity and all
    
    Specified by:
    
    removeActivity in interface InternalVersionManager
    
    Parameters:
    
    session - the current session
    
    nodeId - id of the activity to remove
    
    Throws:
    
    RepositoryException - if an error occurs
  - internalRemoveActivity
```
protected void internalRemoveActivity(org.apache.jackrabbit.core.version.InternalActivityImpl activity)
                               throws VersionException,
                                      RepositoryException
```
    Removes the specified activity
    Before modifying activity, make a local copy of it.
    
    Parameters:
    
    activity - the activity to remove
    
    Throws:
    
    RepositoryException - if any other error occurs.
    
    VersionException
  - canCheckout
```
public NodeId canCheckout(NodeStateEx state,
                          NodeId activityId)
                   throws RepositoryException
```
    invokes the checkout() on the persistent version manager.
    
    Specified by:
    
    canCheckout in interface InternalVersionManager
    
    Parameters:
    
    state - node to checkout
    
    activityId - node id if the current activity
    
    Returns:
    
    the base version id
    
    Throws:
    
    RepositoryException - if an error occurs
  - checkin
```
public InternalVersion checkin(Session session,
                               NodeStateEx node,
                               Calendar created)
                        throws RepositoryException
```
    invokes the checkin() on the persistent version manager and remaps the newly created version objects.
    
    Specified by:
    
    checkin in interface InternalVersionManager
    
    Parameters:
    
    session - session that invokes the checkin
    
    node - node to checkin
    
    created - create time of the new version, or null for the current time
    
    Returns:
    
    the newly created version
    
    Throws:
    
    RepositoryException - if an error occurs
  - removeVersion
```
public void removeVersion(Session session,
                          InternalVersionHistory history,
                          Name versionName)
                   throws RepositoryException
```
    Removes the specified version from the given version history.
    
    Specified by:
    
    removeVersion in interface InternalVersionManager
    
    Parameters:
    
    session - the session that performs the remove
    
    history - version history to remove the version from
    
    versionName - name of the version
    
    Throws:
    
    RepositoryException - if an error occurs
  - removeVersionHistory
```
public void removeVersionHistory(Session session,
                                 InternalVersionHistory history)
                          throws RepositoryException
```
    Removes the specified version history from storage.
    
    Specified by:
    
    removeVersionHistory in interface InternalVersionManager
    
    Parameters:
    
    session - the session that performs the remove
    
    history - the version history to remove
    
    Throws:
    
    RepositoryException - if an error occurs
  - setVersionLabel
```
public InternalVersion setVersionLabel(Session session,
                                       InternalVersionHistory history,
                                       Name version,
                                       Name label,
                                       boolean move)
                                throws RepositoryException
```
    Sets the version label to the given version. If the label is already assigned to another version, a VersionException is thrown unless move is true. If version is null, the label is removed from the respective version. In either case, the version the label was previously assigned is returned, or null of the label was not moved.
    
    Specified by:
    
    setVersionLabel in interface InternalVersionManager
    
    Parameters:
    
    session - the session that performs the operation
    
    history - version history
    
    version - name of the version
    
    label - new label
    
    move - if true label will be moved
    
    Returns:
    
    the version that had the label or null
    
    Throws:
    
    RepositoryException - if an error occurs
  - close
```
public void close()
           throws Exception
```
    Close this version manager. After having closed a persistence manager, further operations on this object are treated as illegal and throw
    
    Specified by:
    
    close in interface InternalVersionManager
    
    Throws:
    
    Exception - if an error occurs
  - isVirtualRoot
```
public boolean isVirtualRoot(ItemId id)
```
    Checks if the id refers to the root of a virtual tree.
    
    Specified by:
    
    isVirtualRoot in interface VirtualItemStateProvider
    
    Returns:
    
    true if it is the root
  - getVirtualRootId
```
public NodeId getVirtualRootId()
```
    Returns the id of the root node of the virtual tree.
    
    Specified by:
    
    getVirtualRootId in interface VirtualItemStateProvider
    
    Returns:
    
    the id of the root node of the virtual tree.
  - getVirtualRootIds
```
public NodeId[] getVirtualRootIds()
```
    Description copied from interface: VirtualItemStateProvider
    
    Returns the ids of the root nodes of the virtual tree.
    
    Specified by:
    
    getVirtualRootIds in interface VirtualItemStateProvider
    
    Returns:
    
    the ids of the roots node of the virtual tree.
  - createPropertyState
```
public VirtualPropertyState createPropertyState(VirtualNodeState parent,
                                                Name name,
                                                int type,
                                                boolean multiValued)
                                         throws RepositoryException
```
    Creats a new virtual property state
    
    Specified by:
    
    createPropertyState in interface VirtualItemStateProvider
    
    Returns:
    
    Throws:
    
    RepositoryException
  - createNodeState
```
public VirtualNodeState createNodeState(VirtualNodeState parent,
                                        Name name,
                                        NodeId id,
                                        Name nodeTypeName)
                                 throws RepositoryException
```
    Creates a new virtual node state
    
    Specified by:
    
    createNodeState in interface VirtualItemStateProvider
    
    id - (must not be null)
    
    Returns:
    
    Throws:
    
    RepositoryException
  - setNodeReferences
```
public boolean setNodeReferences(ChangeLog references)
```
    Informs this provider that the node references to some of its states have changed.
    
    Specified by:
    
    setNodeReferences in interface VirtualItemStateProvider
    
    Parameters:
    
    references - collection of NodeReferences instances
    
    Returns:
    
    true if the reference target is one of its items.
  - getItemState
```
public ItemState getItemState(ItemId id)
                       throws NoSuchItemStateException,
                              ItemStateException
```
    Return an item state, given its item id.
    Return item states for changes only. Global version manager will return other items.
    
    Specified by:
    
    getItemState in interface ItemStateManager
    
    Parameters:
    
    id - item id
    
    Returns:
    
    item state
    
    Throws:
    
    NoSuchItemStateException - if the item does not exist
    
    ItemStateException - if an error occurs
  - hasItemState
```
public boolean hasItemState(ItemId id)
```
    Return a flag indicating whether an item state for a given item id exists.
    
    Specified by:
    
    hasItemState in interface ItemStateManager
    
    Parameters:
    
    id - item id
    
    Returns:
    
    true if an item state exists, otherwise false
  - getNodeReferences
```
public NodeReferences getNodeReferences(NodeId id)
                                 throws NoSuchItemStateException,
                                        ItemStateException
```
    Return a node references object, given its target id
    
    Specified by:
    
    getNodeReferences in interface ItemStateManager
    
    Parameters:
    
    id - target id
    
    Returns:
    
    node references object
    
    Throws:
    
    NoSuchItemStateException - if the item does not exist
    
    ItemStateException - if an error occurs
  - hasNodeReferences
```
public boolean hasNodeReferences(NodeId id)
```
    Return a flag indicating whether a node references object for a given target id exists.
    
    Specified by:
    
    hasNodeReferences in interface ItemStateManager
    
    Parameters:
    
    id - target id
    
    Returns:
    
    true if a node reference object exists for the given id, otherwise false.
  - addListener
```
public void addListener(ItemStateListener listener)
```
    Add an ItemStateListener
    Not needed.
    
    Specified by:
    
    addListener in interface VirtualItemStateProvider
    
    Parameters:
    
    listener - the new listener to be informed on modifications
  - removeListener
```
public void removeListener(ItemStateListener listener)
```
    Remove an ItemStateListener
    Not needed.
    
    Specified by:
    
    removeListener in interface VirtualItemStateProvider
    
    Parameters:
    
    listener - an existing listener
  - getHistoryRoot
```
protected NodeStateEx getHistoryRoot()
```
    returns the id of the version history root node
    
    Returns:
    
    the id of the version history root node
  - getActivitiesRoot
```
protected NodeStateEx getActivitiesRoot()
```
    returns the id of the activities root node
    
    Returns:
    
    the id of the activities root node
  - getItem
```
protected InternalVersionItem getItem(NodeId id)
                               throws RepositoryException
```
    Returns the item with the given persistent id. Subclass responsibility.
    Please note, that the overridden method must acquire the readlock before reading the state manager.
    
    Parameters:
    
    id - the id of the item
    
    Returns:
    
    version item
    
    Throws:
    
    RepositoryException - if an error occurs
  - hasItem
```
protected boolean hasItem(NodeId id)
```
    Return a flag indicating if the item specified exists. Subclass responsibility.
    
    Parameters:
    
    id - the id of the item
    
    Returns:
    
    true if the item exists; false otherwise
  - hasItemReferences
```
protected boolean hasItemReferences(NodeId id)
                             throws RepositoryException
```
    Checks if there are item references (from outside the version storage) that reference the given node. Subclass responsibility.
    Please note, that the overridden method must acquire the readlock before reading the state manager.
    
    Parameters:
    
    id - the id of the node
    
    Returns:
    
    true if there are item references from outside the version storage; false otherwise.
    
    Throws:
    
    RepositoryException - if an error occurs while reading from the repository.
  - getNodeStateEx
```
protected NodeStateEx getNodeStateEx(NodeId parentNodeId)
                              throws RepositoryException
```
    Returns the node with the given persistent id. Subclass responsibility.
    Please note, that the overridden method must acquire the readlock before reading the state manager.
    
    Parameters:
    
    parentNodeId - the id of the node
    
    Returns:
    
    the nodestate for the given id.
    
    Throws:
    
    RepositoryException - if an error occurs while reading from the repository.
  - internalCheckin
```
protected InternalVersion internalCheckin(org.apache.jackrabbit.core.version.InternalVersionHistoryImpl history,
                                          NodeStateEx node,
                                          boolean simple,
                                          Calendar created)
                                   throws RepositoryException
```
    Checks in a node
    Before modifying version history given, make a local copy of it.
    
    Parameters:
    
    history - the version history
    
    node - node to checkin
    
    simple - flag indicates simple versioning
    
    created - optional created date.
    
    Returns:
    
    internal version
    
    Throws:
    
    RepositoryException - if an error occurs
    
    See Also:
    
    Node.checkin()
  - internalRemoveVersion
```
protected void internalRemoveVersion(org.apache.jackrabbit.core.version.InternalVersionHistoryImpl history,
                                     Name name)
                              throws VersionException,
                                     RepositoryException
```
    Removes the specified version from the history
    Before modifying version history given, make a local copy of it.
    
    Parameters:
    
    history - the version history from where to remove the version.
    
    name - the name of the version to remove.
    
    Throws:
    
    VersionException - if the version history does not have a version with name.
    
    RepositoryException - if any other error occurs.
  - setVersionLabel
```
protected InternalVersion setVersionLabel(org.apache.jackrabbit.core.version.InternalVersionHistoryImpl history,
                                          Name version,
                                          Name label,
                                          boolean move)
                                   throws RepositoryException
```
    Set version label on the specified version.
    Before modifying version history given, make a local copy of it.
    
    Parameters:
    
    history - version history
    
    version - version name
    
    label - version label
    
    move - true to move from existing version; false otherwise.
    
    Returns:
    
    The internal version.
    
    Throws:
    
    RepositoryException - if an error occurs
  - versionCreated
```
protected void versionCreated(InternalVersion version)
```
    Invoked when a new internal item has been created.
    Put the version object into our cache.
    
    Parameters:
    
    version - internal version item
  - versionDestroyed
```
protected void versionDestroyed(InternalVersion version)
```
    Invoked when a new internal item has been destroyed.
    Remove the version object from our cache.
    
    Parameters:
    
    version - internal version item
  - associate
```
public void associate(TransactionContext tx)
```
    Associate this resource with a transaction. All further operations on the object should be interpreted as part of this transaction and changes recorded in some attribute of the transaction context.
    
    Specified by:
    
    associate in interface InternalXAResource
    
    Parameters:
    
    tx - transaction context, if null disassociate
  - beforeOperation
```
public void beforeOperation(TransactionContext tx)
```
    Invoked before one of the InternalXAResource.prepare(org.apache.jackrabbit.data.core.TransactionContext), InternalXAResource.commit(org.apache.jackrabbit.data.core.TransactionContext) or InternalXAResource.rollback(org.apache.jackrabbit.data.core.TransactionContext) method is called.
    Delegate the call to our XA item state manager.
    
    Specified by:
    
    beforeOperation in interface InternalXAResource
    
    Parameters:
    
    tx - transaction context
  - prepare
```
public void prepare(TransactionContext tx)
             throws TransactionException
```
    Prepare transaction. The transaction is identified by a transaction context.
    Delegate the call to our XA item state manager.
    
    Specified by:
    
    prepare in interface InternalXAResource
    
    Parameters:
    
    tx - transaction context
    
    Throws:
    
    TransactionException - if an error occurs
  - commit
```
public void commit(TransactionContext tx)
            throws TransactionException
```
    Commit transaction. The transaction is identified by a transaction context. If the method throws, other resources get their changes rolled back.
    Delegate the call to our XA item state manager. If successful, inform global repository manager to update its caches.
    
    Specified by:
    
    commit in interface InternalXAResource
    
    Parameters:
    
    tx - transaction context
    
    Throws:
    
    TransactionException - if an error occurs
  - rollback
```
public void rollback(TransactionContext tx)
```
    Rollback transaction. The transaction is identified by a transaction context.
    Delegate the call to our XA item state manager.
    
    Specified by:
    
    rollback in interface InternalXAResource
    
    Parameters:
    
    tx - transaction context.
  - afterOperation
```
public void afterOperation(TransactionContext tx)
```
    Invoked after one of the InternalXAResource.prepare(org.apache.jackrabbit.data.core.TransactionContext), InternalXAResource.commit(org.apache.jackrabbit.data.core.TransactionContext) or InternalXAResource.rollback(org.apache.jackrabbit.data.core.TransactionContext) method has been called.
    Delegate the call to our XA item state manager.
    
    Specified by:
    
    afterOperation in interface InternalXAResource
    
    Parameters:
    
    tx - transaction context
  - getXAResourceBegin
```
public InternalXAResource getXAResourceBegin()
```
    Returns an InternalXAResource that acquires a write lock on the version manager in InternalXAResource.prepare(TransactionContext).
    
    Returns:
    
    an internal XA resource.
  - getXAResourceEnd
```
public InternalXAResource getXAResourceEnd()
```
    Returns an InternalXAResource that releases the write lock on the version manager in InternalXAResource.commit(TransactionContext) or InternalXAResource.rollback(TransactionContext).
    
    Returns:
    
    an internal XA resource.
  - getVersion
```
public InternalVersion getVersion(NodeId id)
                           throws RepositoryException
```
    Returns the version with the given id
    
    Specified by:
    
    getVersion in interface InternalVersionManager
    
    Parameters:
    
    id - id of the version to retrieve
    
    Returns:
    
    the version or null
    
    Throws:
    
    RepositoryException - if an error occurs
  - getBaseline
```
public InternalBaseline getBaseline(NodeId id)
                             throws RepositoryException
```
    Returns the baseline with the given id
    
    Specified by:
    
    getBaseline in interface InternalVersionManager
    
    Parameters:
    
    id - id of the baseline version to retrieve
    
    Returns:
    
    the baseline or null if not found
    
    Throws:
    
    RepositoryException - if an error occurs
  - getActivity
```
public InternalActivity getActivity(NodeId id)
                             throws RepositoryException
```
    Returns the activity with the given id
    
    Specified by:
    
    getActivity in interface InternalVersionManager
    
    Parameters:
    
    id - id of the activity to retrieve
    
    Returns:
    
    the activity.
    
    Throws:
    
    RepositoryException - if an error occurs
  - getVersionHistory
```
public InternalVersionHistory getVersionHistory(NodeId id)
                                         throws RepositoryException
```
    Returns the version history with the given id
    
    Specified by:
    
    getVersionHistory in interface InternalVersionManager
    
    Parameters:
    
    id - id of the version history
    
    Returns:
    
    the version history.
    
    Throws:
    
    RepositoryException - if an error occurs
  - getVersionHistoryOfNode
```
public InternalVersionHistory getVersionHistoryOfNode(NodeId id)
                                               throws RepositoryException
```
    Returns the version history for the versionable node with the given id.
    
    Specified by:
    
    getVersionHistoryOfNode in interface InternalVersionManager
    
    Parameters:
    
    id - id of the node to retrieve the version history for
    
    Returns:
    
    the version history
    
    Throws:
    
    RepositoryException - if an error occurs or the history does not exit
  - getHeadVersionOfNode
```
public InternalVersion getHeadVersionOfNode(NodeId id)
                                     throws RepositoryException
```
    Returns the head version of the node with the given id. this is always the last of all versions. this only works correctly for liner version graphs (i.e. simple versioning) Assumes that all versions are stored chronologically below the version history and just returns the last one. i.e. currently only works for simple versioning.
    
    Specified by:
    
    getHeadVersionOfNode in interface InternalVersionManager
    
    Parameters:
    
    id - id of the node to retrieve the version for
    
    Returns:
    
    the version.
    
    Throws:
    
    RepositoryException - if an error occurs
  - acquireWriteLock
```
protected VersioningLock.WriteLock acquireWriteLock()
```
    Acquires the write lock on this version manager.
    
    Returns:
    
    returns the write lock
  - acquireReadLock
```
public VersioningLock.ReadLock acquireReadLock()
```
    acquires the read lock on this version manager.
    
    Returns:
    
    returns the read lock
  - getVersionHistoryInfoForNode
```
public VersionHistoryInfo getVersionHistoryInfoForNode(NodeState node)
                                                throws RepositoryException
```
    Returns information about the version history of the specified node or null when unavailable.
    
    Parameters:
    
    node - node whose version history should be returned
    
    Returns:
    
    identifiers of the version history and root version nodes
    
    Throws:
    
    RepositoryException - if an error occurs
  - getVersionHistory
```
public VersionHistoryInfo getVersionHistory(Session session,
                                            NodeState node,
                                            NodeId copiedFrom)
                                     throws RepositoryException
```
    Returns information about the version history of the specified node. If the given node does not already have an associated version history, then an empty history is automatically created. This method should only be called by code that already knows that the specified node is versionable.
    
    Specified by:
    
    getVersionHistory in interface InternalVersionManager
    
    Parameters:
    
    session - workspace session
    
    node - node whose version history should be returned
    
    copiedFrom - the node id for the jcr:copiedFrom property use for copied nodes
    
    Returns:
    
    identifiers of the version history and root version nodes
    
    Throws:
    
    RepositoryException - if an error occurs
  - getName
```
protected static Name getName(String name)
```
    Utility method that returns the given string as a name in the default namespace.
    
    Parameters:
    
    name - string name
    
    Returns:
    
    A Name object.
  - getParentNode
```
protected static NodeStateEx getParentNode(NodeStateEx parent,
                                           String uuid,
                                           Name interNT)
                                    throws RepositoryException
```
    Utility method that returns the parent node under which the version history of the identified versionable node is or will be stored. If the interNT is not null then the returned parent node and any ancestor nodes are automatically created if they do not already exist. Otherwise null is returned if the parent node does not exist.
    
    Parameters:
    
    parent - the parent node
    
    uuid - UUID of a versionable node
    
    interNT - intermediate nodetype.
    
    Returns:
    
    parent node of the version history, or null
    
    Throws:
    
    RepositoryException - if an error occurs
  - checkin
```
protected InternalVersion checkin(NodeStateEx node,
                                  Calendar created)
                           throws RepositoryException
```
    Creates a new version of the given node using the given version creation time.
    
    Parameters:
    
    node - the node to be checked in
    
    created - version creation time
    
    Returns:
    
    the new version
    
    Throws:
    
    RepositoryException - if an error occurs
  - calculateCheckinVersionName
```
protected String calculateCheckinVersionName(org.apache.jackrabbit.core.version.InternalVersionHistoryImpl history,
                                             NodeStateEx node,
                                             boolean simple)
                                      throws RepositoryException
```
    Calculates the name of the new version that will be created by a checkin call. The name is determined as follows:
    - first the predecessor version with the shortest name is searched.
    - if that predecessor version is the root version, the new version gets the name "{number of successors}+1" + ".0"
    - if that predecessor version has no successor, the last digit of it's version number is incremented.
    - if that predecessor version has successors but the incremented name does not exist, that name is used.
    - otherwise a ".0" is added to the name until a non conflicting name is found.
    Example Graph:
```
 jcr:rootVersion
  |     |
 1.0   2.0
  |
 1.1
  |
 1.2 ---\  ------\
  |      \        \
 1.3   1.2.0   1.2.0.0
  |      |
 1.4   1.2.1 ----\
  |      |        \
 1.5   1.2.2   1.2.1.0
  |      |        |
 1.6     |     1.2.1.1
  |-----/
 1.7
 
```
    Parameters:
    
    history - the version history
    
    node - the node to checkin
    
    simple - if true indicates simple versioning
    
    Returns:
    
    the new version name
    
    Throws:
    
    RepositoryException - if an error occurs.
  - internalRemoveVersionHistory
```
public void internalRemoveVersionHistory(org.apache.jackrabbit.core.version.InternalVersionHistoryImpl history)
                                  throws VersionException,
                                         RepositoryException
```
    Removes the specified history from the storage
    
    Parameters:
    
    history - the version history to remove
    
    Throws:
    
    VersionException
    
    RepositoryException
  - itemDiscarded
```
protected void itemDiscarded(InternalVersionItem item)
```
    Invoked by the internal version item itself, when it's underlying persistence state was discarded.
    
    Parameters:
    
    item - item that was discarded
  - createInternalVersionItem
```
protected InternalVersionItem createInternalVersionItem(NodeId id)
                                                 throws RepositoryException
```
    Creates an InternalVersionItem based on the NodeState identified by id.
    
    Parameters:
    
    id - the node id of the version item.
    
    Returns:
    
    the version item or null if there is no node state with the given id.
    
    Throws:
    
    RepositoryException - if an error occurs while reading from the version storage.
  - getNodeIdFactory
```
public NodeIdFactory getNodeIdFactory()
```

Class InternalXAVersionManager

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

stateMgr

ntReg

historiesId

activitiesId

Constructor Detail

InternalXAVersionManager

Method Detail

createEventStateCollection

getVirtualItemStateProvider

createVersionHistory

createActivity

removeActivity

internalRemoveActivity

canCheckout

checkin

removeVersion

removeVersionHistory

setVersionLabel

close

isVirtualRoot

getVirtualRootId

getVirtualRootIds

createPropertyState

createNodeState

setNodeReferences

getItemState

hasItemState

getNodeReferences

hasNodeReferences

addListener

removeListener

getHistoryRoot

getActivitiesRoot

getItem

hasItem

hasItemReferences

getNodeStateEx

internalCheckin

internalRemoveVersion

setVersionLabel

versionCreated

versionDestroyed

associate

beforeOperation

prepare

commit

rollback

afterOperation

getXAResourceBegin

getXAResourceEnd

getVersion

getBaseline

getActivity

getVersionHistory

getVersionHistoryOfNode

getHeadVersionOfNode

acquireWriteLock

acquireReadLock

getVersionHistoryInfoForNode

getVersionHistory

getName

getParentNode

checkin

calculateCheckinVersionName

internalRemoveVersionHistory

itemDiscarded

createInternalVersionItem

getNodeIdFactory