AbstractRepositoryService (Apache Jackrabbit 2.12.11 API)

java.lang.Object
- org.apache.jackrabbit.spi.commons.AbstractRepositoryService

All Implemented Interfaces:

RepositoryService

Direct Known Subclasses:

AbstractReadableRepositoryService
```
public abstract class AbstractRepositoryService
extends Object
implements RepositoryService
```
AbstractRepositoryService provides an abstract base class for repository service implementations. This class provides default implementations for the following methods:

Field Summary

Fields
Modifier and Type	Field and Description
`protected Map<String,QValue[]>`	`descriptors` The repository descriptors.
`protected NamespaceMapping`	`namespaces` The fixed set of namespaces known to the repository service.
`protected NodeTypeStorage`	`nodeTypeDefs` The fixed set of node type definitions known to the repository service.
`protected QNodeDefinition`	`rootNodeDefinition` The node definition of the root node.

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`AbstractRepositoryService()`
	`AbstractRepositoryService(Map<String,QValue[]> descriptors, Map<String,String> namespaces, QNodeTypeDefinition[] nodeTypeDefs)`
	`AbstractRepositoryService(Map<String,QValue[]> descriptors, Map<String,String> namespaces, Reader cnd)`

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`addVersionLabel(SessionInfo sessionInfo, NodeId versionHistoryId, NodeId versionId, Name label, boolean moveLabel)` Add the given version label in the persistent layer.
`protected void`	`checkCredentials(javax.jcr.Credentials credentials, String workspaceName)` Checks if the given `credentials` are valid.
`NodeId`	`checkin(SessionInfo sessionInfo, NodeId nodeId)` Performs a checkin for the `Node` identified by the given `NodeId`.
`void`	`checkout(SessionInfo sessionInfo, NodeId nodeId)` Performs a checkout for the `Node` identified by the given `NodeId`.
`void`	`checkout(SessionInfo sessionInfo, NodeId nodeId, NodeId activityId)` Performs a checkout for the `Node` identified by the given `NodeId` and for activity identified by the specified `activityId`.
`NodeId`	`checkpoint(SessionInfo sessionInfo, NodeId nodeId)` Performs a checkpoint for the `Node` identified by the given `NodeId`.
`NodeId`	`checkpoint(SessionInfo sessionInfo, NodeId nodeId, NodeId activityId)` Performs a checkpoint for the `Node` identified by the given `NodeId`.
`String[]`	`checkQueryStatement(SessionInfo sessionInfo, String statement, String language, Map<String,String> namespaces)` Checks if the query `statement` is valid according to the specified query `language` and returns the bind variable names found in the query statement.
`protected void`	`checkSessionInfo(SessionInfo sessionInfo)` Checks the type of the `sessionInfo` instance.
`protected void`	`checkWorkspace(String workspaceName)` Checks if the given workspace is available.
`void`	`clone(SessionInfo sessionInfo, String srcWorkspaceName, NodeId srcNodeId, NodeId destParentNodeId, Name destName, boolean removeExisting)` Clone the subtree identified by the given `srcNodeId` in workspace named `srcWorkspaceName` to the destination in the workspace specified by the given `SessionInfo`.
`void`	`copy(SessionInfo sessionInfo, String srcWorkspaceName, NodeId srcNodeId, NodeId destParentNodeId, Name destName)` Clone the subtree identified by the given `srcNodeId` in workspace named `srcWorkspaceName` to the destination in the workspace specified by the given `SessionInfo`.
`NodeId`	`createActivity(SessionInfo sessionInfo, String title)` Create a new activity.
`Batch`	`createBatch(SessionInfo sessionInfo, ItemId itemId)` Indicates the start of a set of operations that cause modifications on the underlying persistence layer.
`NodeId`	`createConfiguration(SessionInfo sessionInfo, NodeId nodeId)`
`EventFilter`	`createEventFilter(SessionInfo sessionInfo, int eventTypes, Path absPath, boolean isDeep, String[] uuid, Name[] nodeTypeName, boolean noLocal)` Creates an event filter.
`protected abstract QNodeDefinition`	`createRootNodeDefinition(SessionInfo sessionInfo)` Create the root node definition.
`protected SessionInfo`	`createSessionInfo(javax.jcr.Credentials credentials, String workspaceName)` Creates a session info instance for the given `credentials` and `workspaceName`.
`protected SessionInfo`	`createSessionInfo(SessionInfo sessionInfo, String workspaceName)` Creates a session info instance for the given `sessionInfo` and `workspaceName`.
`Subscription`	`createSubscription(SessionInfo sessionInfo, EventFilter[] filters)` Creates a new `Subscription` for events with an initial set of `EventFilter`s.
`Tree`	`createTree(SessionInfo sessionInfo, Batch batch, Name nodeName, Name primaryTypeName, String uniqueId)` Creates a new `Tree` that can be populated and later on be applied to the specified `Batch` by calling `#setTree`.
`void`	`createWorkspace(SessionInfo sessionInfo, String name, String srcWorkspaceName)` Create a new workspace with the specified `name`.
`void`	`deleteWorkspace(SessionInfo sessionInfo, String name)` Deletes the workspace with the specified `name`.
`void`	`dispose(SessionInfo sessionInfo)` This default implementation does nothing.
`void`	`dispose(Subscription subscription)` Indicates that the passed subscription is no longer needed.
`QueryInfo`	`executeQuery(SessionInfo sessionInfo, String statement, String language, Map<String,String> namespaces, long limit, long offset, Map<String,QValue> values)` Execute the given query statement with the specified query language.
`EventBundle`	`getEvents(SessionInfo sessionInfo, EventFilter filter, long after)` Returns events from the `EventJournal` after a given point in time.
`EventBundle[]`	`getEvents(Subscription subscription, long timeout)` Retrieves the events that occurred since the last call to this method for the passed subscription.
`IdFactory`	`getIdFactory()` Return the `IdFactory`.
`LockInfo`	`getLockInfo(SessionInfo sessionInfo, NodeId nodeId)` Returns the lock information that applies to `Node` identified by the given `NodeId` or `null`.
`NameFactory`	`getNameFactory()` Return the `NameFactory`.
`String`	`getNamespacePrefix(SessionInfo sessionInfo, String uri)` This default implementation first calls `checkSessionInfo(SessionInfo)` with the `sessionInfo`, then return the namespace prefix for the given `uri`.
`String`	`getNamespaceURI(SessionInfo sessionInfo, String prefix)` This default implementation first calls `checkSessionInfo(SessionInfo)` with the `sessionInfo`, then returns the namespace URI for the given `prefix`.
`QNodeDefinition`	`getNodeDefinition(SessionInfo sessionInfo, NodeId nodeId)` This default implementation first calls `checkSessionInfo(SessionInfo)` with the `sessionInfo`, then lazily initializes `rootNodeDefinition` if `nodeId` denotes the root node; otherwise throws a `UnsupportedRepositoryOperationException`.
`PathFactory`	`getPathFactory()` Return the `PathFactory`.
`QPropertyDefinition`	`getPropertyDefinition(SessionInfo sessionInfo, PropertyId propertyId)` Returns the `QPropertyDefinition` for the `Property` identified by the given id.
`Iterator<QNodeTypeDefinition>`	`getQNodeTypeDefinitions(SessionInfo sessionInfo)` This default implementation first calls `checkSessionInfo(SessionInfo)` with the `sessionInfo`,
`Iterator<QNodeTypeDefinition>`	`getQNodeTypeDefinitions(SessionInfo sessionInfo, Name[] nodetypeNames)` This default implementation first calls `checkSessionInfo(SessionInfo)` with the `sessionInfo`, then gathers the `QNodeTypeDefinition`s with the given `nodetypeNames`.
`QValueFactory`	`getQValueFactory()` Return the `QValueFactory` defined with this SPI implementation.
`Map<String,String>`	`getRegisteredNamespaces(SessionInfo sessionInfo)` This default implementation first calls `checkSessionInfo(SessionInfo)` with the `sessionInfo`, then returns the prefix to namespace URL mapping that was provided in the constructor of this repository service.
`Map<String,QValue[]>`	`getRepositoryDescriptors()` This default implementation returns the descriptors that were passed to the constructor of this repository service.
`String[]`	`getSupportedQueryLanguages(SessionInfo sessionInfo)` Returns a String array identifying all query languages supported by this SPI implementation.
`SessionInfo`	`impersonate(SessionInfo sessionInfo, javax.jcr.Credentials credentials)` This default implementation returns the session info returned by the call to `obtain(Credentials, String)` with the workspaceName taken from the passed `sessionInfo`.
`void`	`importXml(SessionInfo sessionInfo, NodeId parentId, InputStream xmlStream, int uuidBehaviour)` Imports the data present in the given `InputStream` into the persistent layer.
`LockInfo`	`lock(SessionInfo sessionInfo, NodeId nodeId, boolean deep, boolean sessionScoped)` Create a lock on the `Node` identified by the given id.
`LockInfo`	`lock(SessionInfo sessionInfo, NodeId nodeId, boolean deep, boolean sessionScoped, long timeoutHint, String ownerHint)` Create a lock on the `Node` identified by the given id.
`Iterator<NodeId>`	`merge(SessionInfo sessionInfo, NodeId nodeId, String srcWorkspaceName, boolean bestEffort)` Merge the node identified by the given `NodeId` and its subtree with the corresponding node present in the workspace with the name of `srcWorkspaceName`.
`Iterator<NodeId>`	`merge(SessionInfo sessionInfo, NodeId nodeId, String srcWorkspaceName, boolean bestEffort, boolean isShallow)` Merge the node identified by the given `NodeId` and its subtree with the corresponding node present in the workspace with the name of `srcWorkspaceName`.
`Iterator<NodeId>`	`mergeActivity(SessionInfo sessionInfo, NodeId activityId)` Merges the activity identified by the given `activityId` into the workspace the specified `sessionInfo` has been created for.
`void`	`move(SessionInfo sessionInfo, NodeId srcNodeId, NodeId destParentNodeId, Name destName)` Moves the node identified by the given `srcNodeId` (and its entire subtree) to the new location defined by `destParentNodeId` and a new name (`destName`).
`SessionInfo`	`obtain(javax.jcr.Credentials credentials, String workspaceName)` This default implementation does: calls `checkCredentials(Credentials, String)` calls `checkWorkspace(String)` calls `createSessionInfo(Credentials, String)`
`SessionInfo`	`obtain(SessionInfo sessionInfo, String workspaceName)` This default implementation returns the session info returned by the call to `createSessionInfo(SessionInfo, String)`.
`void`	`refreshLock(SessionInfo sessionInfo, NodeId nodeId)` Explicit refresh of an existing lock.
`void`	`registerNamespace(SessionInfo sessionInfo, String prefix, String uri)` Register a new namespace with the given prefix and uri.
`void`	`registerNodeTypes(SessionInfo sessionInfo, QNodeTypeDefinition[] nodeTypeDefinitions, boolean allowUpdate)` Registers the node types with the specified `QNodeTypeDefinition`s.
`void`	`removeActivity(SessionInfo sessionInfo, NodeId activityId)` Removes the activity identified by the specified `activityId`.
`void`	`removeVersion(SessionInfo sessionInfo, NodeId versionHistoryId, NodeId versionId)` Remove the version identified by the specified `versionId`.
`void`	`removeVersionLabel(SessionInfo sessionInfo, NodeId versionHistoryId, NodeId versionId, Name label)` Remove the given version label in the persistent layer.
`void`	`resolveMergeConflict(SessionInfo sessionInfo, NodeId nodeId, NodeId[] mergeFailedIds, NodeId[] predecessorIds)` Resolve an existing merge conflict present with the node identified by the given `NodeId`.
`void`	`restore(SessionInfo sessionInfo, NodeId[] versionIds, boolean removeExisting)` Restore multiple versions at once.
`void`	`restore(SessionInfo sessionInfo, NodeId nodeId, NodeId versionId, boolean removeExisting)` Restores the node identified by `nodeId` to the state defined by the version with the specified `versionId`.
`void`	`submit(Batch batch)` Completes the given `Batch` or discard all the previous modifications.
`void`	`unlock(SessionInfo sessionInfo, NodeId nodeId)` Releases the lock on the `Node` identified by the given `NodeId`.
`void`	`unregisterNamespace(SessionInfo sessionInfo, String uri)` Unregister the namespace identified by the given uri
`void`	`unregisterNodeTypes(SessionInfo sessionInfo, Name[] nodeTypeNames)` Unregisters the node types with the specified `names`.
`void`	`update(SessionInfo sessionInfo, NodeId nodeId, String srcWorkspaceName)` Updates the node identified by the given `NodeId` replacing it (an the complete subtree) with a clone of its corresponding node present in the workspace with the given `srcWorkspaceName`.
`void`	`updateEventFilters(Subscription subscription, EventFilter[] filters)` Updates events filters on the subscription.

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

Methods inherited from interface org.apache.jackrabbit.spi.RepositoryService
getChildInfos, getItemInfoCache, getItemInfos, getNodeInfo, getPrivilegeDefinitions, getPrivilegeNames, getPropertyInfo, getReferences, getSupportedPrivileges, getWorkspaceNames, isGranted

- Field Detail
  - descriptors
```
protected final Map<String,QValue[]> descriptors
```
    The repository descriptors.
  - namespaces
```
protected final NamespaceMapping namespaces
```
    The fixed set of namespaces known to the repository service.
  - nodeTypeDefs
```
protected final NodeTypeStorage nodeTypeDefs
```
    The fixed set of node type definitions known to the repository service.
  - rootNodeDefinition
```
protected QNodeDefinition rootNodeDefinition
```
    The node definition of the root node.
- Constructor Detail
  - AbstractRepositoryService
```
protected AbstractRepositoryService()
                             throws javax.jcr.RepositoryException
```
    Throws:
    
    javax.jcr.RepositoryException
  - AbstractRepositoryService
```
public AbstractRepositoryService(Map<String,QValue[]> descriptors,
                         Map<String,String> namespaces,
                         QNodeTypeDefinition[] nodeTypeDefs)
                          throws javax.jcr.RepositoryException
```
    Throws:
    
    javax.jcr.RepositoryException
  - AbstractRepositoryService
```
public AbstractRepositoryService(Map<String,QValue[]> descriptors,
                         Map<String,String> namespaces,
                         Reader cnd)
                          throws javax.jcr.RepositoryException
```
    Throws:
    
    javax.jcr.RepositoryException
- Method Detail
  - getIdFactory
```
public IdFactory getIdFactory()
                       throws javax.jcr.RepositoryException
```
    Description copied from interface: RepositoryService
    
    Return the IdFactory.
    
    Specified by:
    
    getIdFactory in interface RepositoryService
    
    Returns:
    IdFactoryImpl.getInstance().
    
    Throws:
    
    javax.jcr.RepositoryException - if an error occurs.
  - getNameFactory
```
public NameFactory getNameFactory()
                           throws javax.jcr.RepositoryException
```
    Description copied from interface: RepositoryService
    
    Return the NameFactory.
    
    Specified by:
    
    getNameFactory in interface RepositoryService
    
    Returns:
    NameFactoryImpl.getInstance().
    
    Throws:
    
    javax.jcr.RepositoryException - if an error occurs.
  - getPathFactory
```
public PathFactory getPathFactory()
                           throws javax.jcr.RepositoryException
```
    Description copied from interface: RepositoryService
    
    Return the PathFactory.
    
    Specified by:
    
    getPathFactory in interface RepositoryService
    
    Returns:
    PathFactoryImpl.getInstance().
    
    Throws:
    
    javax.jcr.RepositoryException - if an error occurs.
  - getQValueFactory
```
public QValueFactory getQValueFactory()
                               throws javax.jcr.RepositoryException
```
    Description copied from interface: RepositoryService
    
    Return the QValueFactory defined with this SPI implementation.
    
    Specified by:
    
    getQValueFactory in interface RepositoryService
    
    Returns:
    QValueFactoryImpl.getInstance().
    
    Throws:
    
    javax.jcr.RepositoryException - if an error occurs.
  - createRootNodeDefinition
```
protected abstract QNodeDefinition createRootNodeDefinition(SessionInfo sessionInfo)
                                                     throws javax.jcr.RepositoryException
```
    Create the root node definition.
    
    Parameters:
    sessionInfo - the session info.
    
    Returns:
    the root node definition for a workspace.
    
    Throws:
    
    javax.jcr.RepositoryException - if an error occurs.
  - checkCredentials
```
protected void checkCredentials(javax.jcr.Credentials credentials,
                    String workspaceName)
                         throws javax.jcr.LoginException
```
    Checks if the given credentials are valid. This default implementation is empty thus allowing all credentials.
    
    Parameters:
    credentials - the credentials to check.
    workspaceName - the workspace to access.
    
    Throws:
    
    javax.jcr.LoginException - if the credentials are invalid.
  - checkWorkspace
```
protected void checkWorkspace(String workspaceName)
                       throws javax.jcr.NoSuchWorkspaceException
```
    Checks if the given workspace is available. The default implementation is empty thus admitting every workspace name.
    
    Parameters:
    workspaceName - Name of the workspace to check
    
    Throws:
    
    javax.jcr.NoSuchWorkspaceException - If workspaceName is not available.
  - createSessionInfo
```
protected SessionInfo createSessionInfo(javax.jcr.Credentials credentials,
                            String workspaceName)
                                 throws javax.jcr.RepositoryException
```
    Creates a session info instance for the given credentials and workspaceName. This default implementation creates a SessionInfoImpl instance and sets the userId and workspaceName. The user userId is null or the userId from credentials if it is of type SimpleCredentials.
    
    Parameters:
    credentials - the credentials.
    workspaceName - the name of the workspace to access or null for the default workspace.
    
    Returns:
    a session info instance for the given credentials and workspaceName.
    
    Throws:
    
    javax.jcr.RepositoryException
  - createSessionInfo
```
protected SessionInfo createSessionInfo(SessionInfo sessionInfo,
                            String workspaceName)
                                 throws javax.jcr.RepositoryException
```
    Creates a session info instance for the given sessionInfo and workspaceName. This default implementation creates a SessionInfoImpl instance and sets the userId and workspaceName. The user userId is set to the return value of SessionInfo.getUserID().
    
    Parameters:
    sessionInfo - the sessionInfo.
    workspaceName - the name of the workspace to access.
    
    Returns:
    a session info instance for the given credentials and workspaceName.
    
    Throws:
    
    javax.jcr.RepositoryException
  - checkSessionInfo
```
protected void checkSessionInfo(SessionInfo sessionInfo)
                         throws javax.jcr.RepositoryException
```
    Checks the type of the sessionInfo instance. This default implementation checks if sessionInfo is of type SessionInfoImpl, otherwise throws a RepositoryException.
    
    Parameters:
    sessionInfo - the session info to check.
    
    Throws:
    
    javax.jcr.RepositoryException - if the given sessionInfo is not of the required type for this repository service implementation.
  - getRepositoryDescriptors
```
public Map<String,QValue[]> getRepositoryDescriptors()
                                              throws javax.jcr.RepositoryException
```
    This default implementation returns the descriptors that were passed to the constructor of this repository service.
    
    Specified by:
    
    getRepositoryDescriptors in interface RepositoryService
    
    Returns:
    key-value pairs for repository descriptor keys and values.
    
    Throws:
    
    javax.jcr.RepositoryException
    See Also:
    Repository.getDescriptorKeys(), Repository.getDescriptor(String)
  - obtain
```
public SessionInfo obtain(javax.jcr.Credentials credentials,
                 String workspaceName)
                   throws javax.jcr.LoginException,
                          javax.jcr.NoSuchWorkspaceException,
                          javax.jcr.RepositoryException
```
    This default implementation does:
    - calls checkCredentials(Credentials, String)
    - calls checkWorkspace(String)
    - calls createSessionInfo(Credentials, String)
    Specified by:
    
    obtain in interface RepositoryService
    
    Parameters:
    credentials - the credentials for the login.
    workspaceName - the name of the workspace to log in.
    
    Returns:
    the session info.
    
    Throws:
    
    javax.jcr.LoginException - if the credentials are invalid.
    
    javax.jcr.NoSuchWorkspaceException - if workspaceName is unknown.
    
    javax.jcr.RepositoryException - if another error occurs.
  - obtain
```
public SessionInfo obtain(SessionInfo sessionInfo,
                 String workspaceName)
                   throws javax.jcr.LoginException,
                          javax.jcr.NoSuchWorkspaceException,
                          javax.jcr.RepositoryException
```
    This default implementation returns the session info returned by the call to createSessionInfo(SessionInfo, String).
    
    Specified by:
    
    obtain in interface RepositoryService
    
    Parameters:
    sessionInfo - for another workspace
    workspaceName - the name of the workspace the new SessionInfo should be built for. If the specified workspaceName is null the implementation should select a default workspace.
    
    Returns:
    a SessionInfo if authentication was successful.
    
    Throws:
    
    javax.jcr.LoginException - if authentication of the user fails.
    
    javax.jcr.NoSuchWorkspaceException - if the specified workspaceName is not recognized.
    
    javax.jcr.RepositoryException - if an error occurs.
  - impersonate
```
public SessionInfo impersonate(SessionInfo sessionInfo,
                      javax.jcr.Credentials credentials)
                        throws javax.jcr.LoginException,
                               javax.jcr.RepositoryException
```
    This default implementation returns the session info returned by the call to obtain(Credentials, String) with the workspaceName taken from the passed sessionInfo.
    
    Specified by:
    
    impersonate in interface RepositoryService
    
    Returns:
    a SessionInfo if impersonate was successful.
    
    Throws:
    
    javax.jcr.LoginException
    
    javax.jcr.RepositoryException
    See Also:
    Session.impersonate(javax.jcr.Credentials)
  - dispose
```
public void dispose(SessionInfo sessionInfo)
             throws javax.jcr.RepositoryException
```
    This default implementation does nothing.
    
    Specified by:
    
    dispose in interface RepositoryService
    
    Throws:
    
    javax.jcr.RepositoryException
  - getQNodeTypeDefinitions
```
public Iterator<QNodeTypeDefinition> getQNodeTypeDefinitions(SessionInfo sessionInfo)
                                                      throws javax.jcr.RepositoryException
```
    This default implementation first calls checkSessionInfo(SessionInfo) with the sessionInfo,
    
    Specified by:
    
    getQNodeTypeDefinitions in interface RepositoryService
    
    Returns:
    Iterator of QNodeTypeDefinitions.
    
    Throws:
    
    javax.jcr.RepositoryException
    See Also:
    Workspace.getNodeTypeManager(), NodeTypeManager.getAllNodeTypes(), NodeTypeManager.getMixinNodeTypes(), NodeTypeManager.getPrimaryNodeTypes(), NodeTypeManager.getNodeType(String)
  - getQNodeTypeDefinitions
```
public Iterator<QNodeTypeDefinition> getQNodeTypeDefinitions(SessionInfo sessionInfo,
                                                    Name[] nodetypeNames)
                                                      throws javax.jcr.RepositoryException
```
    This default implementation first calls checkSessionInfo(SessionInfo) with the sessionInfo, then gathers the QNodeTypeDefinitions with the given nodetypeNames. If one of the nodetypeNames is not a valid node type definition then a RepositoryException is thrown.
    
    Specified by:
    
    getQNodeTypeDefinitions in interface RepositoryService
    
    nodetypeNames - names of node types to retrieve
    
    Returns:
    QNodeTypeDefinition
    
    Throws:
    
    javax.jcr.nodetype.NoSuchNodeTypeException - if for any of the given names no QNodeTypeDefinition exists.
    
    javax.jcr.RepositoryException
    See Also:
    Workspace.getNodeTypeManager(), NodeTypeManager.getAllNodeTypes(), NodeTypeManager.getMixinNodeTypes(), NodeTypeManager.getPrimaryNodeTypes(), NodeTypeManager.getNodeType(String)
  - getNodeDefinition
```
public QNodeDefinition getNodeDefinition(SessionInfo sessionInfo,
                                NodeId nodeId)
                                  throws javax.jcr.RepositoryException
```
    This default implementation first calls checkSessionInfo(SessionInfo) with the sessionInfo, then lazily initializes rootNodeDefinition if nodeId denotes the root node; otherwise throws a UnsupportedRepositoryOperationException.
    
    Specified by:
    
    getNodeDefinition in interface RepositoryService
    
    Returns:
    The node definition applicable to the Node identified by the given id.
    
    Throws:
    
    javax.jcr.RepositoryException
  - getPropertyDefinition
```
public QPropertyDefinition getPropertyDefinition(SessionInfo sessionInfo,
                                        PropertyId propertyId)
                                          throws javax.jcr.RepositoryException
```
    Description copied from interface: RepositoryService
    
    Returns the QPropertyDefinition for the Property identified by the given id. This method should only be used if the caller is not able to unambiguously determine the applicable definition from the parent node type definition.
    
    Specified by:
    
    getPropertyDefinition in interface RepositoryService
    
    Returns:
    The property definition applicable for the Property identified by the given id.
    
    Throws:
    
    javax.jcr.UnsupportedRepositoryOperationException - always.
    
    javax.jcr.RepositoryException
  - registerNodeTypes
```
public void registerNodeTypes(SessionInfo sessionInfo,
                     QNodeTypeDefinition[] nodeTypeDefinitions,
                     boolean allowUpdate)
                       throws javax.jcr.nodetype.InvalidNodeTypeDefinitionException,
                              javax.jcr.nodetype.NodeTypeExistsException,
                              javax.jcr.UnsupportedRepositoryOperationException,
                              javax.jcr.RepositoryException
```
    Description copied from interface: RepositoryService
    
    Registers the node types with the specified QNodeTypeDefinitions. If allowUpdate is true this method may also be used to reregister existing node types with a modified definition, otherwise this method will fail with NodeTypeExistsException if any of the specified definition has the name of an already registered node type.
    
    Specified by:
    
    registerNodeTypes in interface RepositoryService
    
    Throws:
    
    javax.jcr.UnsupportedRepositoryOperationException - always.
    
    javax.jcr.nodetype.InvalidNodeTypeDefinitionException - If any of the specified definitions is invalid.
    
    javax.jcr.nodetype.NodeTypeExistsException - If any of the specified definitions has the name of an already registered node type and allowUpdate is false.
    
    javax.jcr.RepositoryException - If another error occurs.
    See Also:
    NodeTypeManager.registerNodeTypes(javax.jcr.nodetype.NodeTypeDefinition[], boolean)
  - unregisterNodeTypes
```
public void unregisterNodeTypes(SessionInfo sessionInfo,
                       Name[] nodeTypeNames)
                         throws javax.jcr.UnsupportedRepositoryOperationException,
                                javax.jcr.nodetype.NoSuchNodeTypeException,
                                javax.jcr.RepositoryException
```
    Description copied from interface: RepositoryService
    
    Unregisters the node types with the specified names.
    
    Specified by:
    
    unregisterNodeTypes in interface RepositoryService
    
    Throws:
    
    javax.jcr.UnsupportedRepositoryOperationException - always.
    
    javax.jcr.nodetype.NoSuchNodeTypeException - If any of the specified names has no corresponding registered node type.
    
    javax.jcr.RepositoryException - If another error occurs.
    See Also:
    NodeTypeManager.unregisterNodeTypes(String[])
  - getRegisteredNamespaces
```
public Map<String,String> getRegisteredNamespaces(SessionInfo sessionInfo)
                                           throws javax.jcr.RepositoryException
```
    This default implementation first calls checkSessionInfo(SessionInfo) with the sessionInfo, then returns the prefix to namespace URL mapping that was provided in the constructor of this repository service.
    
    Specified by:
    
    getRegisteredNamespaces in interface RepositoryService
    
    Returns:
    
    Throws:
    
    javax.jcr.RepositoryException
    See Also:
    Workspace.getNamespaceRegistry(), NamespaceRegistry.getPrefixes(), NamespaceRegistry.getURIs()
  - getNamespaceURI
```
public String getNamespaceURI(SessionInfo sessionInfo,
                     String prefix)
                       throws javax.jcr.NamespaceException,
                              javax.jcr.RepositoryException
```
    This default implementation first calls checkSessionInfo(SessionInfo) with the sessionInfo, then returns the namespace URI for the given prefix.
    
    Specified by:
    
    getNamespaceURI in interface RepositoryService
    
    Parameters:
    sessionInfo - the session info.
    prefix - a namespace prefix to resolve.
    
    Returns:
    the namespace URI for the given namespace prefix.
    
    Throws:
    
    javax.jcr.NamespaceException - if prefix is not mapped to a namespace URI.
    
    javax.jcr.RepositoryException - if another error occurs.
    See Also:
    NamespaceRegistry.getURI(String)
  - getNamespacePrefix
```
public String getNamespacePrefix(SessionInfo sessionInfo,
                        String uri)
                          throws javax.jcr.NamespaceException,
                                 javax.jcr.RepositoryException
```
    This default implementation first calls checkSessionInfo(SessionInfo) with the sessionInfo, then return the namespace prefix for the given uri.
    
    Specified by:
    
    getNamespacePrefix in interface RepositoryService
    
    Parameters:
    sessionInfo - the session info.
    uri - the namespace URI.
    
    Returns:
    the namespace prefix.
    
    Throws:
    
    javax.jcr.NamespaceException - if the URI unknown.
    
    javax.jcr.RepositoryException - if another error occurs.
    See Also:
    NamespaceRegistry.getPrefix(String)
  - createBatch
```
public Batch createBatch(SessionInfo sessionInfo,
                ItemId itemId)
                  throws javax.jcr.RepositoryException
```
    Description copied from interface: RepositoryService
    
    Indicates the start of a set of operations that cause modifications on the underlying persistence layer. All modification called on the Batch must be executed at once or non must be executed upon calling RepositoryService.submit(Batch).
    
    Specified by:
    
    createBatch in interface RepositoryService
    
    itemId - Id of the Item that is a common ancestor of all Items affected upon batch execution. This Item might itself be modified within the scope of the Batch.
    
    Returns:
    A Batch indicating the start of a set of transient modifications that will be execute at once upon RepositoryService.submit(Batch).
    
    Throws:
    
    javax.jcr.UnsupportedRepositoryOperationException - always.
    
    javax.jcr.RepositoryException
    See Also:
    Item.save(), Session.save(), Batch
  - submit
```
public void submit(Batch batch)
            throws javax.jcr.PathNotFoundException,
                   javax.jcr.ItemNotFoundException,
                   javax.jcr.nodetype.NoSuchNodeTypeException,
                   javax.jcr.ValueFormatException,
                   javax.jcr.version.VersionException,
                   javax.jcr.lock.LockException,
                   javax.jcr.nodetype.ConstraintViolationException,
                   javax.jcr.AccessDeniedException,
                   javax.jcr.UnsupportedRepositoryOperationException,
                   javax.jcr.RepositoryException
```
    Description copied from interface: RepositoryService
    
    Completes the given Batch or discard all the previous modifications. See RepositoryService.createBatch(SessionInfo,ItemId) for additional information regarding batch creation.
    
    Specified by:
    
    submit in interface RepositoryService
    
    Throws:
    
    javax.jcr.UnsupportedRepositoryOperationException - always.
    
    javax.jcr.PathNotFoundException
    
    javax.jcr.ItemNotFoundException
    
    javax.jcr.nodetype.NoSuchNodeTypeException
    
    javax.jcr.ValueFormatException
    
    javax.jcr.version.VersionException
    
    javax.jcr.lock.LockException
    
    javax.jcr.nodetype.ConstraintViolationException
    
    javax.jcr.AccessDeniedException
    
    javax.jcr.RepositoryException
    See Also:
    Batch
  - createTree
```
public Tree createTree(SessionInfo sessionInfo,
              Batch batch,
              Name nodeName,
              Name primaryTypeName,
              String uniqueId)
                throws javax.jcr.RepositoryException
```
    Description copied from interface: RepositoryService
    
    Creates a new Tree that can be populated and later on be applied to the specified Batch by calling #setTree.
    
    Specified by:
    
    createTree in interface RepositoryService
    
    Returns:
    a new Tree instance.
    
    Throws:
    
    javax.jcr.UnsupportedRepositoryOperationException - always.
    
    javax.jcr.RepositoryException
  - importXml
```
public void importXml(SessionInfo sessionInfo,
             NodeId parentId,
             InputStream xmlStream,
             int uuidBehaviour)
               throws javax.jcr.ItemExistsException,
                      javax.jcr.PathNotFoundException,
                      javax.jcr.version.VersionException,
                      javax.jcr.nodetype.ConstraintViolationException,
                      javax.jcr.lock.LockException,
                      javax.jcr.AccessDeniedException,
                      javax.jcr.UnsupportedRepositoryOperationException,
                      javax.jcr.RepositoryException
```
    Description copied from interface: RepositoryService
    
    Imports the data present in the given InputStream into the persistent layer. Note, that the implementation is responsible for validating the data presented and for the integrity of the repository upon completion.
    
    Specified by:
    
    importXml in interface RepositoryService
    
    Throws:
    
    javax.jcr.UnsupportedRepositoryOperationException - always.
    
    javax.jcr.ItemExistsException
    
    javax.jcr.PathNotFoundException
    
    javax.jcr.version.VersionException
    
    javax.jcr.nodetype.ConstraintViolationException
    
    javax.jcr.lock.LockException
    
    javax.jcr.AccessDeniedException
    
    javax.jcr.RepositoryException
    See Also:
    Workspace.importXML(String, java.io.InputStream, int)
  - move
```
public void move(SessionInfo sessionInfo,
        NodeId srcNodeId,
        NodeId destParentNodeId,
        Name destName)
          throws javax.jcr.ItemExistsException,
                 javax.jcr.PathNotFoundException,
                 javax.jcr.version.VersionException,
                 javax.jcr.nodetype.ConstraintViolationException,
                 javax.jcr.lock.LockException,
                 javax.jcr.AccessDeniedException,
                 javax.jcr.UnsupportedRepositoryOperationException,
                 javax.jcr.RepositoryException
```
    Description copied from interface: RepositoryService
    
    Moves the node identified by the given srcNodeId (and its entire subtree) to the new location defined by destParentNodeId and a new name (destName).
    
    Specified by:
    
    move in interface RepositoryService
    
    Throws:
    
    javax.jcr.UnsupportedRepositoryOperationException - always.
    
    javax.jcr.ItemExistsException
    
    javax.jcr.PathNotFoundException
    
    javax.jcr.version.VersionException
    
    javax.jcr.nodetype.ConstraintViolationException
    
    javax.jcr.lock.LockException
    
    javax.jcr.AccessDeniedException
    
    javax.jcr.RepositoryException
    See Also:
    Workspace.move(String, String)
  - copy
```
public void copy(SessionInfo sessionInfo,
        String srcWorkspaceName,
        NodeId srcNodeId,
        NodeId destParentNodeId,
        Name destName)
          throws javax.jcr.NoSuchWorkspaceException,
                 javax.jcr.nodetype.ConstraintViolationException,
                 javax.jcr.version.VersionException,
                 javax.jcr.AccessDeniedException,
                 javax.jcr.PathNotFoundException,
                 javax.jcr.ItemExistsException,
                 javax.jcr.lock.LockException,
                 javax.jcr.UnsupportedRepositoryOperationException,
                 javax.jcr.RepositoryException
```
    Description copied from interface: RepositoryService
    
    Clone the subtree identified by the given srcNodeId in workspace named srcWorkspaceName to the destination in the workspace specified by the given SessionInfo. The destination is composed by the given parent id and the new name as indicated by destName.
    Note, that srcWorkspaceName may be the same as the one specified within the SessionInfo. In this case the copy corresponds to a copy within a single workspace.
    
    Specified by:
    
    copy in interface RepositoryService
    
    Throws:
    
    javax.jcr.UnsupportedRepositoryOperationException - always.
    
    javax.jcr.NoSuchWorkspaceException
    
    javax.jcr.nodetype.ConstraintViolationException
    
    javax.jcr.version.VersionException
    
    javax.jcr.AccessDeniedException
    
    javax.jcr.PathNotFoundException
    
    javax.jcr.ItemExistsException
    
    javax.jcr.lock.LockException
    
    javax.jcr.RepositoryException
    See Also:
    Workspace.copy(String, String), Workspace.copy(String, String, String)
  - update
```
public void update(SessionInfo sessionInfo,
          NodeId nodeId,
          String srcWorkspaceName)
            throws javax.jcr.NoSuchWorkspaceException,
                   javax.jcr.AccessDeniedException,
                   javax.jcr.lock.LockException,
                   javax.jcr.InvalidItemStateException,
                   javax.jcr.RepositoryException
```
    Description copied from interface: RepositoryService
    
    Updates the node identified by the given NodeId replacing it (an the complete subtree) with a clone of its corresponding node present in the workspace with the given srcWorkspaceName.
    
    Specified by:
    
    update in interface RepositoryService
    
    Throws:
    
    javax.jcr.UnsupportedRepositoryOperationException - always.
    
    javax.jcr.NoSuchWorkspaceException
    
    javax.jcr.AccessDeniedException
    
    javax.jcr.lock.LockException
    
    javax.jcr.InvalidItemStateException
    
    javax.jcr.RepositoryException
    See Also:
    Node.update(String)
  - clone
```
public void clone(SessionInfo sessionInfo,
         String srcWorkspaceName,
         NodeId srcNodeId,
         NodeId destParentNodeId,
         Name destName,
         boolean removeExisting)
           throws javax.jcr.NoSuchWorkspaceException,
                  javax.jcr.nodetype.ConstraintViolationException,
                  javax.jcr.version.VersionException,
                  javax.jcr.AccessDeniedException,
                  javax.jcr.PathNotFoundException,
                  javax.jcr.ItemExistsException,
                  javax.jcr.lock.LockException,
                  javax.jcr.UnsupportedRepositoryOperationException,
                  javax.jcr.RepositoryException
```
    Description copied from interface: RepositoryService
    
    Clone the subtree identified by the given srcNodeId in workspace named srcWorkspaceName to the destination in the workspace specified by the given SessionInfo. The destination is composed by the given parent id and the new name as indicated by destName.
    
    Specified by:
    
    clone in interface RepositoryService
    
    Throws:
    
    javax.jcr.UnsupportedRepositoryOperationException - always.
    
    javax.jcr.NoSuchWorkspaceException
    
    javax.jcr.nodetype.ConstraintViolationException
    
    javax.jcr.version.VersionException
    
    javax.jcr.AccessDeniedException
    
    javax.jcr.PathNotFoundException
    
    javax.jcr.ItemExistsException
    
    javax.jcr.lock.LockException
    
    javax.jcr.RepositoryException
    See Also:
    Workspace.clone(String, String, String, boolean)
  - lock
```
public LockInfo lock(SessionInfo sessionInfo,
            NodeId nodeId,
            boolean deep,
            boolean sessionScoped)
              throws javax.jcr.UnsupportedRepositoryOperationException,
                     javax.jcr.lock.LockException,
                     javax.jcr.AccessDeniedException,
                     javax.jcr.RepositoryException
```
    Description copied from interface: RepositoryService
    
    Create a lock on the Node identified by the given id.
    
    Specified by:
    
    lock in interface RepositoryService
    
    Returns:
    The LockInfo associated with the new lock that has been created.
    
    Throws:
    
    javax.jcr.UnsupportedRepositoryOperationException - always.
    
    javax.jcr.lock.LockException - If the Node identified by the given id cannot be locked due to an existing lock or due to missing mixin type.
    
    javax.jcr.AccessDeniedException
    
    javax.jcr.RepositoryException - If another error occurs.
    See Also:
    Node.lock(boolean, boolean)
  - lock
```
public LockInfo lock(SessionInfo sessionInfo,
            NodeId nodeId,
            boolean deep,
            boolean sessionScoped,
            long timeoutHint,
            String ownerHint)
              throws javax.jcr.UnsupportedRepositoryOperationException,
                     javax.jcr.lock.LockException,
                     javax.jcr.AccessDeniedException,
                     javax.jcr.RepositoryException
```
    Description copied from interface: RepositoryService
    
    Create a lock on the Node identified by the given id.
    
    Specified by:
    
    lock in interface RepositoryService
    
    timeoutHint - long indicating the desired lock timeout in seconds. The implementation is free to ignore the hint.
    ownerHint - String indicating the desired lockOwner info. The implementation is free to ignore the hint.
    
    Returns:
    The LockInfo associated with the new lock that has been created.
    
    Throws:
    
    javax.jcr.UnsupportedRepositoryOperationException - always.
    
    javax.jcr.lock.LockException - If the Node identified by the given id cannot be locked due to an existing lock or due to missing mixin type.
    
    javax.jcr.AccessDeniedException
    
    javax.jcr.RepositoryException - If another error occurs.
    See Also:
    LockManager.lock(String, boolean, boolean, long, String)
  - getLockInfo
```
public LockInfo getLockInfo(SessionInfo sessionInfo,
                   NodeId nodeId)
                     throws javax.jcr.AccessDeniedException,
                            javax.jcr.RepositoryException
```
    Description copied from interface: RepositoryService
    
    Returns the lock information that applies to Node identified by the given NodeId or null. If the implementation does not support locking at all, this method always returns null.
    
    Specified by:
    
    getLockInfo in interface RepositoryService
    
    Returns:
    null.
    
    Throws:
    
    javax.jcr.AccessDeniedException
    
    javax.jcr.RepositoryException - If some other error occurs.
    See Also:
    Node.getLock()
  - refreshLock
```
public void refreshLock(SessionInfo sessionInfo,
               NodeId nodeId)
                 throws javax.jcr.UnsupportedRepositoryOperationException,
                        javax.jcr.lock.LockException,
                        javax.jcr.AccessDeniedException,
                        javax.jcr.RepositoryException
```
    Description copied from interface: RepositoryService
    
    Explicit refresh of an existing lock. Existing locks should be refreshed implicitly with all read and write methods listed here.
    
    Specified by:
    
    refreshLock in interface RepositoryService
    
    Throws:
    
    javax.jcr.UnsupportedRepositoryOperationException - always.
    
    javax.jcr.lock.LockException - If the Node identified by the given id is not locked (any more) or if the SessionInfo does not contain the token associated with the lock to be refreshed.
    
    javax.jcr.AccessDeniedException
    
    javax.jcr.RepositoryException - If another error occurs.
    See Also:
    Lock
  - unlock
```
public void unlock(SessionInfo sessionInfo,
          NodeId nodeId)
            throws javax.jcr.UnsupportedRepositoryOperationException,
                   javax.jcr.lock.LockException,
                   javax.jcr.AccessDeniedException,
                   javax.jcr.RepositoryException
```
    Description copied from interface: RepositoryService
    
    Releases the lock on the Node identified by the given NodeId.
    Please note, that on logout all session-scoped locks must be released by calling unlock.
    
    Specified by:
    
    unlock in interface RepositoryService
    
    Throws:
    
    javax.jcr.UnsupportedRepositoryOperationException - always.
    
    javax.jcr.lock.LockException - If the Node identified by the given id is not locked or if the SessionInfo does not contain the token associated with the lock to be released.
    
    javax.jcr.AccessDeniedException
    
    javax.jcr.RepositoryException - If another error occurs.
    See Also:
    Node.unlock()
  - checkin
```
public NodeId checkin(SessionInfo sessionInfo,
             NodeId nodeId)
               throws javax.jcr.version.VersionException,
                      javax.jcr.UnsupportedRepositoryOperationException,
                      javax.jcr.InvalidItemStateException,
                      javax.jcr.lock.LockException,
                      javax.jcr.RepositoryException
```
    Description copied from interface: RepositoryService
    
    Performs a checkin for the Node identified by the given NodeId.
    
    Specified by:
    
    checkin in interface RepositoryService
    
    Returns:
    NodeId of newly created version
    
    Throws:
    
    javax.jcr.UnsupportedRepositoryOperationException - always.
    
    javax.jcr.version.VersionException
    
    javax.jcr.InvalidItemStateException
    
    javax.jcr.lock.LockException
    
    javax.jcr.RepositoryException
    See Also:
    Node.checkin()
  - checkout
```
public void checkout(SessionInfo sessionInfo,
            NodeId nodeId)
              throws javax.jcr.UnsupportedRepositoryOperationException,
                     javax.jcr.lock.LockException,
                     javax.jcr.RepositoryException
```
    Description copied from interface: RepositoryService
    
    Performs a checkout for the Node identified by the given NodeId. Same as RepositoryService.checkout(SessionInfo, NodeId, NodeId) where the activityId is null.
    
    Specified by:
    
    checkout in interface RepositoryService
    
    Throws:
    
    javax.jcr.UnsupportedRepositoryOperationException - always.
    
    javax.jcr.lock.LockException
    
    javax.jcr.RepositoryException
    See Also:
    Node.checkout()
  - checkout
```
public void checkout(SessionInfo sessionInfo,
            NodeId nodeId,
            NodeId activityId)
              throws javax.jcr.UnsupportedRepositoryOperationException,
                     javax.jcr.lock.LockException,
                     javax.jcr.RepositoryException
```
    Description copied from interface: RepositoryService
    
    Performs a checkout for the Node identified by the given NodeId and for activity identified by the specified activityId. If the activityId is null this corresponds to RepositoryService.checkout(SessionInfo, NodeId)
    
    Specified by:
    
    checkout in interface RepositoryService
    
    activityId - Id of the activity node set to the editing session or null if no activity is in effect.
    
    Throws:
    
    javax.jcr.UnsupportedRepositoryOperationException - always.
    
    javax.jcr.lock.LockException
    
    javax.jcr.RepositoryException
  - checkpoint
```
public NodeId checkpoint(SessionInfo sessionInfo,
                NodeId nodeId)
                  throws javax.jcr.UnsupportedRepositoryOperationException,
                         javax.jcr.lock.LockException,
                         javax.jcr.RepositoryException
```
    Description copied from interface: RepositoryService
    
    Performs a checkpoint for the Node identified by the given NodeId.
    
    Specified by:
    
    checkpoint in interface RepositoryService
    
    Returns:
    NodeId of newly created version
    
    Throws:
    
    javax.jcr.UnsupportedRepositoryOperationException - always.
    
    javax.jcr.RepositoryException
    
    javax.jcr.lock.LockException
    See Also:
    VersionManager.checkpoint(String)
  - checkpoint
```
public NodeId checkpoint(SessionInfo sessionInfo,
                NodeId nodeId,
                NodeId activityId)
                  throws javax.jcr.UnsupportedRepositoryOperationException,
                         javax.jcr.lock.LockException,
                         javax.jcr.RepositoryException
```
    Description copied from interface: RepositoryService
    
    Performs a checkpoint for the Node identified by the given NodeId. For the checkout part the specified activityId is taken into account as specified in RepositoryService.checkout(SessionInfo, NodeId, NodeId).
    
    Specified by:
    
    checkpoint in interface RepositoryService
    
    activityId - Id of the activity node set to the editing session or null if no activity is in effect.
    
    Throws:
    
    javax.jcr.UnsupportedRepositoryOperationException - always.
    
    javax.jcr.lock.LockException
    
    javax.jcr.RepositoryException
  - removeVersion
```
public void removeVersion(SessionInfo sessionInfo,
                 NodeId versionHistoryId,
                 NodeId versionId)
                   throws javax.jcr.ReferentialIntegrityException,
                          javax.jcr.AccessDeniedException,
                          javax.jcr.UnsupportedRepositoryOperationException,
                          javax.jcr.version.VersionException,
                          javax.jcr.RepositoryException
```
    Description copied from interface: RepositoryService
    
    Remove the version identified by the specified versionId.
    
    Specified by:
    
    removeVersion in interface RepositoryService
    
    versionHistoryId - NodeId identifying the version history the version identified by versionId belongs to.
    
    Throws:
    
    javax.jcr.UnsupportedRepositoryOperationException - always.
    
    javax.jcr.ReferentialIntegrityException
    
    javax.jcr.AccessDeniedException
    
    javax.jcr.version.VersionException
    
    javax.jcr.RepositoryException
    See Also:
    VersionHistory.removeVersion(String)
  - restore
```
public void restore(SessionInfo sessionInfo,
           NodeId nodeId,
           NodeId versionId,
           boolean removeExisting)
             throws javax.jcr.version.VersionException,
                    javax.jcr.PathNotFoundException,
                    javax.jcr.ItemExistsException,
                    javax.jcr.UnsupportedRepositoryOperationException,
                    javax.jcr.lock.LockException,
                    javax.jcr.InvalidItemStateException,
                    javax.jcr.RepositoryException
```
    Description copied from interface: RepositoryService
    
    Restores the node identified by nodeId to the state defined by the version with the specified versionId.
    
    Specified by:
    
    restore in interface RepositoryService
    
    removeExisting - boolean flag indicating how to deal with an identifier collision that may occur if a node exists outside the subtree to be restored with the same identified as a node that would be introduces by the restore. If the removeExisting is true the restored node takes precedence and the existing node is removed. Otherwise the restore fails.
    
    Throws:
    
    javax.jcr.UnsupportedRepositoryOperationException - always.
    
    javax.jcr.version.VersionException
    
    javax.jcr.PathNotFoundException
    
    javax.jcr.ItemExistsException
    
    javax.jcr.lock.LockException
    
    javax.jcr.InvalidItemStateException
    
    javax.jcr.RepositoryException
    See Also:
    Node.restore(String, boolean), Node.restore(javax.jcr.version.Version, boolean), Node.restore(javax.jcr.version.Version, String, boolean), Node.restoreByLabel(String, boolean)
  - restore
```
public void restore(SessionInfo sessionInfo,
           NodeId[] versionIds,
           boolean removeExisting)
             throws javax.jcr.ItemExistsException,
                    javax.jcr.UnsupportedRepositoryOperationException,
                    javax.jcr.version.VersionException,
                    javax.jcr.lock.LockException,
                    javax.jcr.InvalidItemStateException,
                    javax.jcr.RepositoryException
```
    Description copied from interface: RepositoryService
    
    Restore multiple versions at once. The versions to be restored are identified by the given array of NodeIds.
    
    Specified by:
    
    restore in interface RepositoryService
    
    removeExisting - boolean flag indicating how to deal with an identifier collision that may occur if a node exists outside the subtrees to be restored with the same identified as any node that would be introduces by the restore. If the removeExisting is true the node to be restored takes precedence and the existing node is removed. Otherwise the restore fails.
    
    Throws:
    
    javax.jcr.UnsupportedRepositoryOperationException - always.
    
    javax.jcr.ItemExistsException
    
    javax.jcr.version.VersionException
    
    javax.jcr.lock.LockException
    
    javax.jcr.InvalidItemStateException
    
    javax.jcr.RepositoryException
    See Also:
    Workspace.restore(javax.jcr.version.Version[], boolean)
  - merge
```
public Iterator<NodeId> merge(SessionInfo sessionInfo,
                     NodeId nodeId,
                     String srcWorkspaceName,
                     boolean bestEffort)
                       throws javax.jcr.NoSuchWorkspaceException,
                              javax.jcr.AccessDeniedException,
                              javax.jcr.MergeException,
                              javax.jcr.lock.LockException,
                              javax.jcr.InvalidItemStateException,
                              javax.jcr.RepositoryException
```
    Description copied from interface: RepositoryService
    
    Merge the node identified by the given NodeId and its subtree with the corresponding node present in the workspace with the name of srcWorkspaceName.
    
    Specified by:
    
    merge in interface RepositoryService
    
    Returns:
    an Iterator over the NodeIds of all nodes that received a merge result of "fail" in the course of this operation.
    
    Throws:
    
    javax.jcr.UnsupportedRepositoryOperationException - always.
    
    javax.jcr.NoSuchWorkspaceException
    
    javax.jcr.AccessDeniedException
    
    javax.jcr.MergeException
    
    javax.jcr.lock.LockException
    
    javax.jcr.InvalidItemStateException
    
    javax.jcr.RepositoryException
    See Also:
    Node.merge(String, boolean)
  - merge
```
public Iterator<NodeId> merge(SessionInfo sessionInfo,
                     NodeId nodeId,
                     String srcWorkspaceName,
                     boolean bestEffort,
                     boolean isShallow)
                       throws javax.jcr.NoSuchWorkspaceException,
                              javax.jcr.AccessDeniedException,
                              javax.jcr.MergeException,
                              javax.jcr.lock.LockException,
                              javax.jcr.InvalidItemStateException,
                              javax.jcr.RepositoryException
```
    Description copied from interface: RepositoryService
    
    Merge the node identified by the given NodeId and its subtree with the corresponding node present in the workspace with the name of srcWorkspaceName.
    
    Specified by:
    
    merge in interface RepositoryService
    
    Returns:
    an Iterator over the NodeIds of all nodes that received a merge result of "fail" in the course of this operation.
    
    Throws:
    
    javax.jcr.UnsupportedRepositoryOperationException - always.
    
    javax.jcr.NoSuchWorkspaceException
    
    javax.jcr.AccessDeniedException
    
    javax.jcr.MergeException
    
    javax.jcr.lock.LockException
    
    javax.jcr.InvalidItemStateException
    
    javax.jcr.RepositoryException
    See Also:
    VersionManager.merge(String, String, boolean, boolean)
  - resolveMergeConflict
```
public void resolveMergeConflict(SessionInfo sessionInfo,
                        NodeId nodeId,
                        NodeId[] mergeFailedIds,
                        NodeId[] predecessorIds)
                          throws javax.jcr.version.VersionException,
                                 javax.jcr.InvalidItemStateException,
                                 javax.jcr.UnsupportedRepositoryOperationException,
                                 javax.jcr.RepositoryException
```
    Description copied from interface: RepositoryService
    
    Resolve an existing merge conflict present with the node identified by the given NodeId.
    
    Specified by:
    
    resolveMergeConflict in interface RepositoryService
    
    mergeFailedIds - The NodeIds remaining in the jcr:mergeFailed REFERENCE property. The version id(s) to be resolved were removed from the array and added to the predecessor ids in case of Node.doneMerge(Version). In case of a Node.cancelMerge(Version) the version id only gets removed from the list.
    predecessorIds - The complete set of predecessor id including those that have been added in order to resolve a merge conflict.
    
    Throws:
    
    javax.jcr.UnsupportedRepositoryOperationException - always.
    
    javax.jcr.version.VersionException
    
    javax.jcr.InvalidItemStateException
    
    javax.jcr.RepositoryException
    See Also:
    Node.cancelMerge(javax.jcr.version.Version), Node.doneMerge(javax.jcr.version.Version)
  - addVersionLabel
```
public void addVersionLabel(SessionInfo sessionInfo,
                   NodeId versionHistoryId,
                   NodeId versionId,
                   Name label,
                   boolean moveLabel)
                     throws javax.jcr.version.VersionException,
                            javax.jcr.RepositoryException
```
    Description copied from interface: RepositoryService
    
    Add the given version label in the persistent layer.
    
    Specified by:
    
    addVersionLabel in interface RepositoryService
    
    versionHistoryId - NodeId identifying the version history the version identified by versionId belongs to.
    versionId - NodeId identifying the version the label belongs to.
    label - The label to be added.
    moveLabel - If the label is already assigned to a version within the same version history this parameter has the following effect: If true the label already present gets moved to be now be a label of the version indicated by versionId. If false this method fails and the label remains with the original version.
    
    Throws:
    
    javax.jcr.UnsupportedRepositoryOperationException - always.
    
    javax.jcr.version.VersionException
    
    javax.jcr.RepositoryException
    See Also:
    VersionHistory.addVersionLabel(String, String, boolean)
  - removeVersionLabel
```
public void removeVersionLabel(SessionInfo sessionInfo,
                      NodeId versionHistoryId,
                      NodeId versionId,
                      Name label)
                        throws javax.jcr.version.VersionException,
                               javax.jcr.RepositoryException
```
    Description copied from interface: RepositoryService
    
    Remove the given version label in the persistent layer.
    
    Specified by:
    
    removeVersionLabel in interface RepositoryService
    
    versionHistoryId - NodeId identifying the version history the version identified by versionId belongs to.
    versionId - NodeId identifying the version the label belongs to.
    label - The label to be removed.
    
    Throws:
    
    javax.jcr.UnsupportedRepositoryOperationException - always.
    
    javax.jcr.version.VersionException
    
    javax.jcr.RepositoryException
    See Also:
    VersionHistory.removeVersionLabel(String)
  - createActivity
```
public NodeId createActivity(SessionInfo sessionInfo,
                    String title)
                      throws javax.jcr.UnsupportedRepositoryOperationException,
                             javax.jcr.RepositoryException
```
    Description copied from interface: RepositoryService
    
    Create a new activity.
    
    Specified by:
    
    createActivity in interface RepositoryService
    
    Returns:
    the NodeId of the new activity node.
    
    Throws:
    
    javax.jcr.UnsupportedRepositoryOperationException - always.
    
    javax.jcr.RepositoryException
    See Also:
    VersionManager.createActivity(String)
  - removeActivity
```
public void removeActivity(SessionInfo sessionInfo,
                  NodeId activityId)
                    throws javax.jcr.UnsupportedRepositoryOperationException,
                           javax.jcr.RepositoryException
```
    Description copied from interface: RepositoryService
    
    Removes the activity identified by the specified activityId.
    
    Specified by:
    
    removeActivity in interface RepositoryService
    
    Throws:
    
    javax.jcr.UnsupportedRepositoryOperationException - always.
    
    javax.jcr.RepositoryException
    See Also:
    VersionManager.removeActivity(Node)
  - mergeActivity
```
public Iterator<NodeId> mergeActivity(SessionInfo sessionInfo,
                             NodeId activityId)
                               throws javax.jcr.UnsupportedRepositoryOperationException,
                                      javax.jcr.RepositoryException
```
    Description copied from interface: RepositoryService
    
    Merges the activity identified by the given activityId into the workspace the specified sessionInfo has been created for.
    
    Specified by:
    
    mergeActivity in interface RepositoryService
    
    Returns:
    an Iterator over the NodeIds of all nodes that received a merge result of "fail" in the course of this operation.
    
    Throws:
    
    javax.jcr.UnsupportedRepositoryOperationException - always.
    
    javax.jcr.RepositoryException
  - createConfiguration
```
public NodeId createConfiguration(SessionInfo sessionInfo,
                         NodeId nodeId)
                           throws javax.jcr.UnsupportedRepositoryOperationException,
                                  javax.jcr.RepositoryException
```
    Specified by:
    
    createConfiguration in interface RepositoryService
    
    Returns:
    
    Throws:
    
    javax.jcr.UnsupportedRepositoryOperationException - always.
    
    javax.jcr.RepositoryException
    See Also:
    VersionManager.createConfiguration(String)
  - createEventFilter
```
public EventFilter createEventFilter(SessionInfo sessionInfo,
                            int eventTypes,
                            Path absPath,
                            boolean isDeep,
                            String[] uuid,
                            Name[] nodeTypeName,
                            boolean noLocal)
                              throws javax.jcr.UnsupportedRepositoryOperationException,
                                     javax.jcr.RepositoryException
```
    Description copied from interface: RepositoryService
    
    Creates an event filter. If the repository supports observation, the filter created is based on the parameters available in ObservationManager.addEventListener(javax.jcr.observation.EventListener, int, java.lang.String, boolean, java.lang.String[], java.lang.String[], boolean).
    Note, that an SPI implementation may support observation even if the corresponding repository descriptor does not return 'true'.
    
    Specified by:
    
    createEventFilter in interface RepositoryService
    
    Parameters:
    sessionInfo - the session info which requests an event filter.
    eventTypes - A combination of one or more event type constants encoded as a bitmask.
    absPath - An absolute path.
    isDeep - A boolean.
    uuid - Array of jcr:uuid properties.
    nodeTypeName - Array of node type names.
    noLocal - A boolean.
    
    Returns:
    the event filter instance with the given parameters.
    
    Throws:
    
    javax.jcr.UnsupportedRepositoryOperationException - always.
    
    javax.jcr.RepositoryException - if an error occurs while creating the EventFilter.
    See Also:
    ObservationManager.addEventListener(javax.jcr.observation.EventListener, int, String, boolean, String[], String[], boolean)
  - createSubscription
```
public Subscription createSubscription(SessionInfo sessionInfo,
                              EventFilter[] filters)
                                throws javax.jcr.UnsupportedRepositoryOperationException,
                                       javax.jcr.RepositoryException
```
    Description copied from interface: RepositoryService
    
    Creates a new Subscription for events with an initial set of EventFilters. The returned subscription must provide events from the time when the subscription was created. If an empty array of filters is passed no events will be available through the created subscription unless the filters are later updated by calling RepositoryService.updateEventFilters(Subscription, EventFilter[]).
    
    Specified by:
    
    createSubscription in interface RepositoryService
    
    Parameters:
    sessionInfo - the session info.
    filters - the initial event filters for the subscription.
    
    Returns:
    
    Throws:
    
    javax.jcr.UnsupportedRepositoryOperationException - always.
    
    javax.jcr.RepositoryException - if an error occurs while creating the Subscription.
  - updateEventFilters
```
public void updateEventFilters(Subscription subscription,
                      EventFilter[] filters)
                        throws javax.jcr.RepositoryException
```
    Description copied from interface: RepositoryService
    
    Updates events filters on the subscription. When this method returns all events that go through the passed subscription and have been generated after this method call must be filtered using the passed filters.
    An implementation is required to accept at least event filter instances created by RepositoryService.createEventFilter(org.apache.jackrabbit.spi.SessionInfo, int, org.apache.jackrabbit.spi.Path, boolean, java.lang.String[], org.apache.jackrabbit.spi.Name[], boolean). Optionally an implementation may also support event filters instanciated by the client itself. An implementation may require special deployment in that case, e.g. to make the event filter implementation class available to the repository server.
    Note on thread-safety: it is permissible to call this methods while another thread is blocked in calling RepositoryService.getEvents(Subscription, long) using the same subscription instance as a parameter.
    
    Specified by:
    
    updateEventFilters in interface RepositoryService
    
    Parameters:
    subscription - the subscription where the event filters are applied.
    filters - the filters that are applied to the events as they occurred on the repository. An event is included in an event bundle if it is accepted by at least one of the supplied filters. If an empty array is passed none of the potential events are include in an event bundle. This allows a client to skip or ignore events for a certain period of time.
    
    Throws:
    
    javax.jcr.UnsupportedRepositoryOperationException - always.
    
    javax.jcr.RepositoryException - if an error occurs while updating the event filters.
  - getEvents
```
public EventBundle[] getEvents(Subscription subscription,
                      long timeout)
                        throws javax.jcr.RepositoryException,
                               InterruptedException
```
    Description copied from interface: RepositoryService
    
    Retrieves the events that occurred since the last call to this method for the passed subscription.
    Note, that an SPI implementation may support observation even if the corresponding repository descriptor does return 'false'.
    An implementation should un-block a calling thread and let it return if the associated subscription is disposed by another thread.
    
    Specified by:
    
    getEvents in interface RepositoryService
    
    Parameters:
    subscription - a subscription.
    timeout - a timeout in milliseconds to wait at most for an event bundle. If timeout is up and no event occurred meanwhile an empty array is returned.
    
    Returns:
    an array of EventBundles representing the events that occurred.
    
    Throws:
    
    javax.jcr.UnsupportedRepositoryOperationException - always.
    
    javax.jcr.RepositoryException - if an error occurs while retrieving the event bundles.
    
    InterruptedException - if the calling thread is interrupted while waiting for events within the specified timeout.
  - getEvents
```
public EventBundle getEvents(SessionInfo sessionInfo,
                    EventFilter filter,
                    long after)
                      throws javax.jcr.RepositoryException,
                             javax.jcr.UnsupportedRepositoryOperationException
```
    Description copied from interface: RepositoryService
    
    Returns events from the EventJournal after a given point in time. The returned event bundle may only contain events up to a given time. In order to retrieve more events a client must call this method again with the timestamp from the last event bundle. An empty bundle indicates that there are no more events.
    
    Specified by:
    
    getEvents in interface RepositoryService
    
    Parameters:
    sessionInfo - the session info.
    filter - the event filter to apply. Please note: the noLocal flag is ignored.
    after - retrieve events that occurred after the given timestamp.
    
    Returns:
    the event bundle.
    
    Throws:
    
    javax.jcr.UnsupportedRepositoryOperationException - always.
    
    javax.jcr.RepositoryException - if an error occurs.
  - dispose
```
public void dispose(Subscription subscription)
             throws javax.jcr.RepositoryException
```
    Description copied from interface: RepositoryService
    
    Indicates that the passed subscription is no longer needed.
    Note on thread-safety: it is permissible to call this methods while another thread is blocked in calling RepositoryService.getEvents(Subscription, long) using the same subscription instance as a parameter.
    
    Specified by:
    
    dispose in interface RepositoryService
    
    Throws:
    
    javax.jcr.UnsupportedRepositoryOperationException - always.
    
    javax.jcr.RepositoryException - if an error occurs while the subscription is disposed.
  - registerNamespace
```
public void registerNamespace(SessionInfo sessionInfo,
                     String prefix,
                     String uri)
                       throws javax.jcr.NamespaceException,
                              javax.jcr.UnsupportedRepositoryOperationException,
                              javax.jcr.AccessDeniedException,
                              javax.jcr.RepositoryException
```
    Description copied from interface: RepositoryService
    
    Register a new namespace with the given prefix and uri.
    
    Specified by:
    
    registerNamespace in interface RepositoryService
    
    prefix - Prefix of the namespace to be registered.
    uri - Namespace URI to be registered.
    
    Throws:
    
    javax.jcr.UnsupportedRepositoryOperationException - always.
    
    javax.jcr.NamespaceException
    
    javax.jcr.AccessDeniedException
    
    javax.jcr.RepositoryException
    See Also:
    NamespaceRegistry.registerNamespace(String, String)
  - unregisterNamespace
```
public void unregisterNamespace(SessionInfo sessionInfo,
                       String uri)
                         throws javax.jcr.NamespaceException,
                                javax.jcr.UnsupportedRepositoryOperationException,
                                javax.jcr.AccessDeniedException,
                                javax.jcr.RepositoryException
```
    Description copied from interface: RepositoryService
    
    Unregister the namespace identified by the given uri
    
    Specified by:
    
    unregisterNamespace in interface RepositoryService
    
    uri - Namespace URI to be unregistered.
    
    Throws:
    
    javax.jcr.UnsupportedRepositoryOperationException - always.
    
    javax.jcr.NamespaceException
    
    javax.jcr.AccessDeniedException
    
    javax.jcr.RepositoryException
    See Also:
    NamespaceRegistry.unregisterNamespace(String)
  - createWorkspace
```
public void createWorkspace(SessionInfo sessionInfo,
                   String name,
                   String srcWorkspaceName)
                     throws javax.jcr.AccessDeniedException,
                            javax.jcr.UnsupportedRepositoryOperationException,
                            javax.jcr.NoSuchWorkspaceException,
                            javax.jcr.RepositoryException
```
    Description copied from interface: RepositoryService
    
    Create a new workspace with the specified name. If srcWorkspaceName isn't null the content of that workspace is 'cloned' to the new workspace as inital content, otherwise an empty workspace will be created.
    
    Specified by:
    
    createWorkspace in interface RepositoryService
    
    name - The name of the new workspace.
    srcWorkspaceName - The name of the workspace from which the initial content of the new workspace will be 'cloned'.
    
    Throws:
    
    javax.jcr.UnsupportedRepositoryOperationException - always.
    
    javax.jcr.AccessDeniedException
    
    javax.jcr.NoSuchWorkspaceException
    
    javax.jcr.RepositoryException
    See Also:
    Workspace.createWorkspace(String), Workspace.createWorkspace(String, String)
  - deleteWorkspace
```
public void deleteWorkspace(SessionInfo sessionInfo,
                   String name)
                     throws javax.jcr.AccessDeniedException,
                            javax.jcr.UnsupportedRepositoryOperationException,
                            javax.jcr.NoSuchWorkspaceException,
                            javax.jcr.RepositoryException
```
    Description copied from interface: RepositoryService
    
    Deletes the workspace with the specified name.
    
    Specified by:
    
    deleteWorkspace in interface RepositoryService
    
    name - The name of the workspace to be deleted.
    
    Throws:
    
    javax.jcr.UnsupportedRepositoryOperationException - always.
    
    javax.jcr.AccessDeniedException
    
    javax.jcr.NoSuchWorkspaceException
    
    javax.jcr.RepositoryException
    See Also:
    Workspace.deleteWorkspace(String)
  - getSupportedQueryLanguages
```
public String[] getSupportedQueryLanguages(SessionInfo sessionInfo)
                                    throws javax.jcr.RepositoryException
```
    Description copied from interface: RepositoryService
    
    Returns a String array identifying all query languages supported by this SPI implementation.
    
    Specified by:
    
    getSupportedQueryLanguages in interface RepositoryService
    
    Returns:
    String array identifying all query languages supported by this SPI implementation.
    
    Throws:
    
    javax.jcr.RepositoryException
    See Also:
    QueryManager.getSupportedQueryLanguages()
  - checkQueryStatement
```
public String[] checkQueryStatement(SessionInfo sessionInfo,
                           String statement,
                           String language,
                           Map<String,String> namespaces)
                             throws javax.jcr.query.InvalidQueryException,
                                    javax.jcr.RepositoryException
```
    Description copied from interface: RepositoryService
    
    Checks if the query statement is valid according to the specified query language and returns the bind variable names found in the query statement.
    
    Specified by:
    
    checkQueryStatement in interface RepositoryService
    
    Parameters:
    sessionInfo - the session info.
    statement - the query statement to check.
    language - the query language.
    namespaces - the locally re-mapped namespace which may be used in the query statement.
    
    Returns:
    the bind variable names.
    
    Throws:
    
    javax.jcr.query.InvalidQueryException - if the query statement is invalid or the language is not supported.
    
    javax.jcr.RepositoryException - if an error occurs while checking the statement.
    See Also:
    QueryManager.createQuery(String, String)
  - executeQuery
```
public QueryInfo executeQuery(SessionInfo sessionInfo,
                     String statement,
                     String language,
                     Map<String,String> namespaces,
                     long limit,
                     long offset,
                     Map<String,QValue> values)
                       throws javax.jcr.RepositoryException
```
    Description copied from interface: RepositoryService
    
    Execute the given query statement with the specified query language. The additional namespaces parameter provides a mapping of prefix to namespace uri in order to be able to properly resolve prefix:localname patterns present within the query statement.
    
    Specified by:
    
    executeQuery in interface RepositoryService
    
    Parameters:
    sessionInfo - the session info that wants to execute the query.
    statement - the query statement to be execute.
    language - the query language used to parse the query statement.
    namespaces - the locally re-mapped namespace which may be used in the query statement.
    limit - The maximum result size or -1 is no maximum is set.
    offset - The offset in the total result set or -1 is no offset is set.
    values - A Map of name/value pairs collected upon calls to Query.bindValue(String, javax.jcr.Value).
    
    Returns:
    The query info.
    
    Throws:
    
    javax.jcr.RepositoryException - if an error occurs.
    See Also:
    Query.execute()

Class AbstractRepositoryService

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.apache.jackrabbit.spi.RepositoryService

Field Detail

descriptors

namespaces

nodeTypeDefs

rootNodeDefinition

Constructor Detail

AbstractRepositoryService

AbstractRepositoryService

AbstractRepositoryService

Method Detail

getIdFactory

getNameFactory

getPathFactory

getQValueFactory

createRootNodeDefinition

checkCredentials

checkWorkspace

createSessionInfo

createSessionInfo

checkSessionInfo

getRepositoryDescriptors

obtain

obtain

impersonate

dispose

getQNodeTypeDefinitions

getQNodeTypeDefinitions

getNodeDefinition

getPropertyDefinition

registerNodeTypes

unregisterNodeTypes

getRegisteredNamespaces

getNamespaceURI

getNamespacePrefix

createBatch

submit

createTree

importXml

move

copy

update

clone

lock

lock

getLockInfo

refreshLock

unlock

checkin

checkout

checkout

checkpoint

checkpoint

removeVersion

restore

restore

merge

merge

resolveMergeConflict

addVersionLabel

removeVersionLabel

createActivity

removeActivity

mergeActivity

createConfiguration

createEventFilter

createSubscription

updateEventFilters

getEvents

getEvents

dispose

registerNamespace

unregisterNamespace

createWorkspace

deleteWorkspace