InternalVersionManagerImpl (Apache Jackrabbit 2.20.16 API)

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

All Implemented Interfaces:

UpdateEventListener, ItemStateListener, InternalVersionManager
```
public class InternalVersionManagerImpl
extends Object
implements ItemStateListener, UpdateEventListener
```
This Class implements a VersionManager.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class InternalVersionManagerImpl.DynamicESCFactory

Nested Classes
Modifier and Type	Class and Description
`static class`	`InternalVersionManagerImpl.DynamicESCFactory`

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
`InternalVersionManagerImpl(PersistenceManager pMgr, FileSystem fs, NodeTypeRegistry ntReg, DelegatingObservationDispatcher obsMgr, NodeId systemId, NodeId historiesId, NodeId activitiesId, ItemStateCacheFactory cacheFactory, ISMLocking ismLocking, NodeIdFactory nodeIdFactory)` Creates a new internal version manager

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.
`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.
`NodeId`	`createActivity(Session session, String title)` Creates a new activity
`protected InternalVersionItem`	`createInternalVersionItem(NodeId id)` Creates an `InternalVersionItem` based on the `NodeState` identified by `id`.
`protected VersionItemStateManager`	`createItemStateManager(PersistenceManager pMgr, NodeId rootId, NodeTypeRegistry ntReg, ItemStateCacheFactory cacheFactory, ISMLocking ismLocking, NodeIdFactory nodeIdFactory)` Creates a `VersionItemStateManager` or derivative.
`protected VersionHistoryInfo`	`createVersionHistory(Session session, NodeState node, NodeId copiedFrom)` Creates a new version history.
`void`	`externalUpdate(ChangeLog changes, List<EventState> events, long timestamp, String userData)` Handle an external update.
`protected NodeStateEx`	`getActivitiesRoot()` returns 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
`InternalVersionManagerImpl.DynamicESCFactory`	`getEscFactory()` Returns the event state collection factory.
`InternalVersion`	`getHeadVersionOfNode(NodeId id)` Returns the head version of the node with the given id.
`protected NodeStateEx`	`getHistoryRoot()` returns the version history root node
`protected InternalVersionItem`	`getItem(NodeId id)` Returns the item with the given persistent id.
`protected static Name`	`getName(String name)` Utility method that returns the given string as a name in the default namespace.
`NodeIdFactory`	`getNodeIdFactory()`
`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.
`PersistenceManager`	`getPersistenceManager()` Return the persistence manager.
`protected SharedItemStateManager`	`getSharedStateMgr()` Returns the shared item state manager.
`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.
`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.
`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
`protected void`	`itemDiscarded(InternalVersionItem item)` Invoked by the internal version item itself, when it's underlying persistence state was discarded.
`void`	`itemsUpdated(Collection<InternalVersionItem> items)` Invoked by some external source to indicate that some items in the versions tree were updated.
`void`	`removeActivity(Session session, NodeId nodeId)` Removes an activity and all
`void`	`removeVersion(Session session, InternalVersionHistory history, Name name)` Removes the specified version from the given version history.
`void`	`removeVersionHistory(Session session, InternalVersionHistory history)` Removes the specified version history from storage.
`void`	`setEventChannel(UpdateEventChannel eventChannel)` Set an event channel to inform about updates.
`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`.
`void`	`stateCreated(ItemState created)` Called when an `ItemState` has successfully been created (i.e.
`void`	`stateDestroyed(ItemState destroyed)` Called when an `ItemState` has successfully been removed (i.e.
`void`	`stateDiscarded(ItemState discarded)` Called when an `ItemState` has been discarded (i.e.
`void`	`stateModified(ItemState modified)` Called when an `ItemState` has successfully been modified (i.e.
`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
  - InternalVersionManagerImpl
```
public InternalVersionManagerImpl(PersistenceManager pMgr,
                                  FileSystem fs,
                                  NodeTypeRegistry ntReg,
                                  DelegatingObservationDispatcher obsMgr,
                                  NodeId systemId,
                                  NodeId historiesId,
                                  NodeId activitiesId,
                                  ItemStateCacheFactory cacheFactory,
                                  ISMLocking ismLocking,
                                  NodeIdFactory nodeIdFactory)
                           throws RepositoryException
```
    Creates a new internal version manager
    
    Parameters:
    
    pMgr - underlying persistence manager
    
    fs - workspace file system
    
    ntReg - node type registry
    
    obsMgr - observation manager
    
    systemId - node id of the version storage parent (i.e. jcr:system)
    
    historiesId - node id of the version storage (i.e. jcr:versionStorage)
    
    activitiesId - node id of the activities storage (i.e. jcr:activities)
    
    cacheFactory - item state cache factory
    
    ismLocking - workspace item state locking
    
    Throws:
    
    RepositoryException - if an error occurs
- Method Detail
  - 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.
  - getPersistenceManager
```
public PersistenceManager getPersistenceManager()
```
    Return the persistence manager.
    
    Returns:
    
    the persistence manager
  - 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
  - getEscFactory
```
public InternalVersionManagerImpl.DynamicESCFactory getEscFactory()
```
    Returns the event state collection factory.
    
    Returns:
    
    the event state collection factory.
  - 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.
    This method must not be synchronized since it could cause deadlocks with item-reading listeners in the observation thread.
    
    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
    This method must not be synchronized since it could cause deadlocks with item-reading listeners in the observation thread.
    
    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
    This method must not be synchronized since it could cause deadlocks with item-reading listeners in the observation thread.
    
    Specified by:
    
    removeActivity in interface InternalVersionManager
    
    Parameters:
    
    session - the current session
    
    nodeId - id of the activity to remove
    
    Throws:
    
    RepositoryException - if an error occurs
  - hasItem
```
public 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
  - 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
  - canCheckout
```
public NodeId canCheckout(NodeStateEx state,
                          NodeId activityId)
                   throws RepositoryException
```
    invokes the checkout() on the persistent version manager. this method currently does no modifications to the persistence and just checks if the checkout is valid in respect to a possible activity set on the session
    
    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.
    This method must not be synchronized since it could cause deadlocks with item-reading listeners in the observation thread.
    
    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 name)
                   throws VersionException,
                          RepositoryException
```
    Removes the specified version from the given version history.
    This method must not be synchronized since it could cause deadlocks with item-reading listeners in the observation thread.
    
    Specified by:
    
    removeVersion in interface InternalVersionManager
    
    Parameters:
    
    session - the session that performs the remove
    
    history - version history to remove the version from
    
    name - name of the version
    
    Throws:
    
    RepositoryException - if an error occurs
    
    VersionException
  - removeVersionHistory
```
public void removeVersionHistory(Session session,
                                 InternalVersionHistory history)
                          throws RepositoryException
```
    Removes the specified version history from storage.
    This method must not be synchronized since it could cause deadlocks with item-reading listeners in the observation thread.
    
    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.
    This method must not be synchronized since it could cause deadlocks with item-reading listeners in the observation thread.
    
    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
  - itemsUpdated
```
public void itemsUpdated(Collection<InternalVersionItem> items)
```
    Invoked by some external source to indicate that some items in the versions tree were updated. Version histories are reloaded if possible. Matching items are removed from the cache.
    
    Parameters:
    
    items - items updated
  - setEventChannel
```
public void setEventChannel(UpdateEventChannel eventChannel)
```
    Set an event channel to inform about updates.
    
    Parameters:
    
    eventChannel - event channel
  - 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
  - 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.
  - getHistoryRoot
```
protected NodeStateEx getHistoryRoot()
```
    returns the version history root node
    
    Returns:
    
    the version history root node
  - getActivitiesRoot
```
protected NodeStateEx getActivitiesRoot()
```
    returns the activities root node
    
    Returns:
    
    the activities root node
  - getSharedStateMgr
```
protected SharedItemStateManager getSharedStateMgr()
```
    Returns the shared item state manager.
    
    Returns:
    
    the shared item state manager.
  - createItemStateManager
```
protected VersionItemStateManager createItemStateManager(PersistenceManager pMgr,
                                                         NodeId rootId,
                                                         NodeTypeRegistry ntReg,
                                                         ItemStateCacheFactory cacheFactory,
                                                         ISMLocking ismLocking,
                                                         NodeIdFactory nodeIdFactory)
                                                  throws ItemStateException
```
    Creates a VersionItemStateManager or derivative.
    
    Parameters:
    
    pMgr - persistence manager
    
    rootId - root node id
    
    ntReg - node type registry
    
    cacheFactory - cache factory
    
    ismLocking - the ISM locking implementation
    
    Returns:
    
    item state manager
    
    Throws:
    
    ItemStateException - if an error occurs
  - stateCreated
```
public void stateCreated(ItemState created)
```
    Called when an ItemState has successfully been created (i.e. its underlying persistent state was created).
    Not used.
    
    Specified by:
    
    stateCreated in interface ItemStateListener
    
    Parameters:
    
    created - the ItemState that has been 'created'
  - stateModified
```
public void stateModified(ItemState modified)
```
    Called when an ItemState has successfully been modified (i.e. its underlying persistent state has changed).
    Not used.
    
    Specified by:
    
    stateModified in interface ItemStateListener
    
    Parameters:
    
    modified - the ItemState that has been 'modified'
  - stateDestroyed
```
public void stateDestroyed(ItemState destroyed)
```
    Called when an ItemState has successfully been removed (i.e. its underlying persistent state has been destroyed).
    Remove item from cache on removal.
    
    Specified by:
    
    stateDestroyed in interface ItemStateListener
    
    Parameters:
    
    destroyed - the ItemState that has been 'destroyed'
  - stateDiscarded
```
public void stateDiscarded(ItemState discarded)
```
    Called when an ItemState has been discarded (i.e. it has been rendered 'invalid').
    Not used.
    
    Specified by:
    
    stateDiscarded in interface ItemStateListener
    
    Parameters:
    
    discarded - the ItemState that has been discarded
    
    See Also:
    
    ItemState.discard()
  - externalUpdate
```
public void externalUpdate(ChangeLog changes,
                           List<EventState> events,
                           long timestamp,
                           String userData)
                    throws RepositoryException
```
    Handle an external update.
    
    Specified by:
    
    externalUpdate in interface UpdateEventListener
    
    Parameters:
    
    changes - external changes containing only node and property ids.
    
    events - events to deliver
    
    timestamp - when the change occurred.
    
    userData - the user data associated with this update.
    
    Throws:
    
    RepositoryException - if the update cannot be processed
  - 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
  - internalRemoveActivity
```
protected void internalRemoveActivity(org.apache.jackrabbit.core.version.InternalActivityImpl activity)
                               throws RepositoryException
```
    Removes the specified activity
    
    Parameters:
    
    activity - the activity to remove
    
    Throws:
    
    RepositoryException - if any other 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
  - internalCheckin
```
protected InternalVersion internalCheckin(org.apache.jackrabbit.core.version.InternalVersionHistoryImpl history,
                                          NodeStateEx node,
                                          boolean simple,
                                          Calendar created)
                                   throws RepositoryException
```
    Checks in a node
    
    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()
  - 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.
  - internalRemoveVersion
```
protected void internalRemoveVersion(org.apache.jackrabbit.core.version.InternalVersionHistoryImpl history,
                                     Name name)
                              throws VersionException,
                                     RepositoryException
```
    Removes the specified version from the history
    
    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.
  - 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
  - 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.
    
    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.
    
    Parameters:
    
    version - internal version item
  - versionDestroyed
```
protected void versionDestroyed(InternalVersion version)
```
    Invoked when a new internal item has been destroyed.
    
    Parameters:
    
    version - internal version item
  - 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 InternalVersionManagerImpl

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

stateMgr

ntReg

historiesId

activitiesId

Constructor Detail

InternalVersionManagerImpl

Method Detail

getVirtualItemStateProvider

getPersistenceManager

close

getEscFactory

createVersionHistory

createActivity

removeActivity

hasItem

getItem

canCheckout

checkin

removeVersion

removeVersionHistory

setVersionLabel

itemsUpdated

setEventChannel

itemDiscarded

hasItemReferences

getNodeStateEx

getHistoryRoot

getActivitiesRoot

getSharedStateMgr

createItemStateManager

stateCreated

stateModified

stateDestroyed

stateDiscarded

externalUpdate

getVersion

getBaseline

getActivity

getVersionHistory

getVersionHistoryOfNode

getHeadVersionOfNode

acquireWriteLock

acquireReadLock

getVersionHistoryInfoForNode

getVersionHistory

internalRemoveActivity

getName

getParentNode

checkin

internalCheckin

calculateCheckinVersionName

internalRemoveVersion

internalRemoveVersionHistory

setVersionLabel

versionCreated

versionDestroyed

createInternalVersionItem

getNodeIdFactory