| javax.jcr.Workspace
| Workspace | | public interface Workspace (Code) | | The Workspace object represents a "view" of an actual repository workspace
entity as seen through the authorization settings of its associated Session.
Each Workspace object is associated one-to-one with a Session
object. The Workspace object can be acquired by calling
Session.getWorkspace on the associated Session object.
|
| Method Summary | |
| public String | clone(String srcWorkspace, String srcAbsPath, String destAbsPath, boolean removeExisting)
Clones the subtree at the node srcAbsPath in srcWorkspace to the new location at
destAbsPath in this workspace. | | public String | copy(String srcAbsPath, String destAbsPath)
This method copies the node at srcAbsPath to the new
location at destAbsPath. | | public String | copy(String srcWorkspace, String srcAbsPath, String destAbsPath)
This method copies the subtree at srcAbsPath in srcWorkspace
to destAbsPath in this workspace. | | public Node | createActivity(String title)
This method creates a new nt:activity at an implementation-determined
location in the /jcr:system/jcr:activities subtree.
The repository may, but is not required to, use the title
as a hint for what to name the new activity node. | | public void | createWorkspace(String name)
Creates a new Workspace with the specified
name. | | public void | createWorkspace(String name, String srcWorkspace)
Creates a new Workspace with the specified name
initialized with a clone of the content of the workspace
srcWorkspace. | | public void | deleteWorkspace(String name)
Deletes the workspace with the specified name from the
repository, deleting all content within it. | | public String[] | getAccessibleWorkspaceNames()
Returns a string array containing the names of all workspaces
in this repository that are accessible to this user, given the
Credentials that were used to get the Session
to which this Workspace is tied. | | public ContentHandler | getImportContentHandler(String parentAbsPath, int uuidBehavior)
Returns an org.xml.sax.ContentHandler which can be used to push SAX events into the repository.
If the incoming XML stream (in the form of SAX events) does not appear to be a JCR system view XML document then it is
interpreted as a document view XML document.
The incoming XML is deserialized into a subtree of items immediately below the node at
parentAbsPath.
This method simply returns the ContentHandler without altering the state of the
repository; the actual deserialization is done through the methods of the ContentHandler.
Invalid XML data will cause the ContentHandler to throw a SAXException.
As SAX events are fed into the ContentHandler, changes are made directly at the
workspace level, without going through the Session. | | public String | getName()
Returns the name of the actual persistent workspace represented by this
Workspace object. | | public NamespaceRegistry | getNamespaceRegistry()
Returns the NamespaceRegistry object, which is used to access the mapping between
prefixes and namespaces. | | public NodeTypeManager | getNodeTypeManager()
Returns the NodeTypeManager through which node type
information can be queried. | | public ObservationManager | getObservationManager()
Returns the ObservationManager object.
If the implementation does not support observation, an
UnsupportedRepositoryOperationException is thrown.
throws:
UnsupportedRepositoryOperationException - if the implementation doesnot support observation.
throws:
RepositoryException - if an error occurs. | | public QueryManager | getQueryManager()
Returns the QueryManager object, through search methods are accessed.
throws:
RepositoryException - if an error occurs. | | public Session | getSession()
Returns the Session object through which this Workspace
object was acquired. | | public void | importXML(String parentAbsPath, InputStream in, int uuidBehavior)
Deserializes an XML document and adds the resulting item subtree as a child of the node at
parentAbsPath.
If the incoming XML stream does not appear to be a JCR system view XML document then it is interpreted as a
document view XML document.
The passed InputStream is closed before this method returns either
normally or because of an exception.
Changes are made directly at the workspace level, without going through the Session.
As a result, there is not need to call save. | | public NodeIterator | merge(Node activityNode)
This method merges the changes that were made under the specified
activity into this workspace.
An activity A will be associated with a set of versions through the
jcr:activity reference of each version node in the set. | | public String | move(String srcAbsPath, String destAbsPath)
Moves the node at srcAbsPath (and its entire subtree) to the
new location at destAbsPath. | | public void | restore(Version[] versions, boolean removeExisting)
Restores a set of versions at once. |
| clone | | public String clone(String srcWorkspace, String srcAbsPath, String destAbsPath, boolean removeExisting) throws NoSuchWorkspaceException, ConstraintViolationException, VersionException, AccessDeniedException, PathNotFoundException, ItemExistsException, LockException, RepositoryException(Code) | | Clones the subtree at the node srcAbsPath in srcWorkspace to the new location at
destAbsPath in this workspace. Returns the path
of the node at its new position. Note that the returned
path will indicate the resulting same-name sibling index of the
destination, if necessary, unlike the supplied destAbsPath
parameter (see below).
Unlike the signature of copy that copies between workspaces,
this method does not assign new identifiers to the newly cloned nodes
but preserves the identifiers of their respective source nodes. This applies
to both referenceable and non-referenceable nodes.
In some implementations there may be cases where preservation of a
non-referenceable identifier is not possible, due to how non-referenceable
identifiers are constructed in that implementation. In such a case this
method will throw a RepositoryException.
If removeExisting is true and an existing node in this workspace
(the destination workspace) has the same identifier as a node being cloned from
srcWorkspace, then the incoming node takes precedence, and the
existing node (and its subtree) is removed. If removeExisting
is false then an identifier collision causes this method to throw a
ItemExistsException and no changes are made.
If successful, the change is persisted immediately, there is no need to call save.
The destAbsPath provided must not have an index on its final
element. If it does then a RepositoryException is thrown.
Strictly speaking, the destAbsPath parameter is actually an
absolute path to the parent node of the new location, appended
with the new name desired for the cloned node. It does not specify
a position within the child node ordering. If ordering is supported by
the node type of the parent node of the new location, then the new clone
of the node is appended to the end of the child node list. The resulting
position within a same-name sibling set can, however, be determined from
the path returned by this method, which will include an index, if one is
required.
This method cannot be used to clone just an individual property by itself. It clones an
entire node and its subtree (including, of course, any properties contained therein).
A NoSuchWorkspaceException is thrown if srcWorkspace does not
exist or if the current Session does not have permission to access it.
A ConstraintViolationException is thrown if the operation would violate a node-type
or other implementation-specific constraint or if srcWorkspace is the name of this workspace.
In other words, if an attempt is made to clone a subtree into the same workspace.
A VersionException is thrown if the parent node of destAbsPath is
versionable and checked-in, or is non-versionable but its nearest versionable ancestor is
checked-in. This exception will also be thrown if removeExisting is true,
and an identifier conflict occurs that would require the moving and/or altering of a node that is checked-in.
An AccessDeniedException is thrown if the current session (i.e. the session that
was used to acquire this Workspace object) does not have sufficient access rights
to complete the operation.
A PathNotFoundException is thrown if the node at srcAbsPath in
srcWorkspace or the parent of destAbsPath in this workspace does not exist.
An ItemExistsException is thrown if a node or property already exists at
destAbsPath
An ItemExistException is thrown if a node already exists at
destAbsPath and same-name siblings are not allowed or if
removeExisting is false and an identifier conflict occurs.
Note that if a property already exists at destAbsPath, the
operation succeeds, since a node may have a child node and property with
the same name.
A LockException is thrown if a lock prevents the clone.
Parameters:
srcWorkspace - The name of the workspace from which the node is to be copied.
Parameters:
srcAbsPath - the path of the node to be copied in srcWorkspace.
Parameters:
destAbsPath - the location to which the node at srcAbsPathis to be copied in this workspace.
Parameters:
removeExisting - if false then this method throws anItemExistsException on identifier conflict with an incoming node.If true then a identifier conflict is resolved by removing the existing nodefrom its location in this workspace and cloning (copying in) the one fromsrcWorkspace. the path of the node at its new position.
throws:
NoSuchWorkspaceException - if destWorkspace does not exist.
throws:
ConstraintViolationException - if the operation would violate anode-type or other implementation-specific constraint.
throws:
VersionException - if the parent node of destAbsPath isversionable and checked-in, or is non-versionable but its nearest versionable ancestor ischecked-in. This exception will also be thrown if removeExisting is true,and an identifier conflict occurs that would require the moving and/or altering of a node that is checked-in.
throws:
AccessDeniedException - if the current session does not havesufficient access rights to complete the operation.
throws:
PathNotFoundException - if the node at srcAbsPath insrcWorkspace or the parent of destAbsPath in this workspace does not exist.
throws:
ItemExistsException - if a node already exists atdestAbsPath and same-name siblings are not allowed or ifremoveExisting is false and an identifier conflict occurs.
throws:
LockException - if a lock prevents the clone.
throws:
RepositoryException - if the last element of destAbsPathhas an index or if another error occurs. |
| copy | | public String copy(String srcAbsPath, String destAbsPath) throws ConstraintViolationException, VersionException, AccessDeniedException, PathNotFoundException, ItemExistsException, LockException, RepositoryException(Code) | | This method copies the node at srcAbsPath to the new
location at destAbsPath. Returns the path of the node at its
new position. Note that the returned path will indicate the resulting
same-name sibling index of the destination, if necessary, unlike the
supplied destAbsPath parameter (see below).
This operation is performed entirely within the persistent workspace, it
does not involve transient storage and therefore does not require a
save.
The new copies of nodes are automatically given new identifiers and
referenceable nodes in particular are always given new referenceable
identifiers.
When the source subtree in a copy operation includes both a reference
property (P) and the node to which it refers (N)
then not only does the new copy of the referenceable node (N')
get a new identifier but the new copy of the reference property (P')
is changed so that it points to N', thus preserving the
reference within the subtree.
The destAbsPath provided must not have an index on its final
element. If it does then a RepositoryException is thrown.
Strictly speaking, the destAbsPath parameter is actually an
absolute path to the parent node of the new location, appended
with the new name desired for the copied node. It does not specify
a position within the child node ordering. If ordering is supported by
the node type of the parent node of the new location, then the new copy
of the node is appended to the end of the child node list. The resulting
position within a same-name sibling set can, however, be determined from
the path returned by this method, which will include an index if one is
required.
This method cannot be used to copy just an individual property by itself.
It copies an entire node and its subtree (including, of course, any properties contained therein).
A ConstraintViolationException is thrown if the operation would violate a node-type
or other implementation-specific constraint.
A VersionException is thrown if the parent node of destAbsPath is
versionable and checked-in, or is non-versionable but its nearest versionable ancestor is
checked-in.
An AccessDeniedException is thrown if the current session (i.e. the session that
was used to acquire this Workspace object) does not have sufficient access rights
to complete the operation.
A PathNotFoundException is thrown if the node at srcAbsPath or the
parent of destAbsPath does not exist.
An ItemExistException is thrown if a node already exists at
destAbsPath and same-name siblings are not allowed. Note that
if a property already exists at destAbsPath, the operation
succeeds, since a node may have a child node and property with the same name.
A LockException is thrown if a lock prevents the copy.
Parameters:
srcAbsPath - the path of the node to be copied.
Parameters:
destAbsPath - the location to which the node at srcAbsPathis to be copied. the path of the node at its new position.
throws:
ConstraintViolationException - if the operation would violate anode-type or other implementation-specific constraint.
throws:
VersionException - if the parent node of destAbsPath isversionable and checked-in, or is non-versionable but its nearest versionable ancestor ischecked-in.
throws:
AccessDeniedException - if the current session does not havesufficient access rights to complete the operation.
throws:
PathNotFoundException - if the node at srcAbsPath orthe parent of destAbsPath does not exist.
throws:
ItemExistsException - if a node already exists atdestAbsPath and same-name siblings are not allowed.
throws:
LockException - if a lock prevents the copy.
throws:
RepositoryException - if the last element of destAbsPathhas an index or if another error occurs. |
| copy | | public String copy(String srcWorkspace, String srcAbsPath, String destAbsPath) throws NoSuchWorkspaceException, ConstraintViolationException, VersionException, AccessDeniedException, PathNotFoundException, ItemExistsException, LockException, RepositoryException(Code) | | This method copies the subtree at srcAbsPath in srcWorkspace
to destAbsPath in this workspace. Returns the
path of the node at its new position. Note that the returned path will
indicate the resulting same-name sibling index of the destination,
if necessary, unlike the supplied destAbsPath parameter
(see below).
Unlike clone, this method does assign new referenceable
identifiers to the new copies of referenceable nodes. In the case of
non-referenceable nodes, this method may assign new identifiers. This
operation is performed entirely within the persistent workspace, it does
not involve transient storage and therefore does not require a save.
When the source subtree in a copy operation includes both a reference
property (P) and the node to which it refers (N)
then not only does the new copy of the referenceable node (N')
get a new identifier but the new copy of the reference property (P')
is changed so that it points to N', thus preserving the
reference within the subtree.
The destAbsPath provided must not have an index on its final
element. If it does then a RepositoryException is thrown.
Strictly speaking, the destAbsPath parameter is actually an
absolute path to the parent node of the new location, appended
with the new name desired for the copied node. It does not specify
a position within the child node ordering. If ordering is supported by
the node type of the parent node of the new location, then the new copy
of the node is appended to the end of the child node list. The resulting
position within a same-name sibling set can, however, be determined from
the path returned by this method, which will include an index if one is
required.
This method cannot be used to copy just an individual property by itself.
It copies an entire node and its subtree (including, of course, any properties contained therein).
A NoSuchWorkspaceException is thrown if srcWorkspace does not
exist or if the current Session does not have permission to access it.
A ConstraintViolationException is thrown if the operation would violate a node-type
or other implementation-specific constraint.
A VersionException is thrown if the parent node of destAbsPath is
versionable and checked-in, or is non-versionable but its nearest versionable ancestor is
checked-in.
An AccessDeniedException is thrown if the current session (i.e. the session that
was used to acquire this Workspace object) does not have sufficient access rights
to complete the operation.
A PathNotFoundException is thrown if the node at srcAbsPath in
srcWorkspace or the parent of destAbsPath in this workspace does not exist.
An ItemExistException is thrown if a node already exists at
destAbsPath and same-name siblings are not allowed. Note that
if a property already exists at destAbsPath, the operation
succeeds, since a node may have a child node and property with the same name.
A LockException is thrown if a lock prevents the copy.
Parameters:
srcWorkspace - the name of the workspace from which the copy is to be made.
Parameters:
srcAbsPath - the path of the node to be copied.
Parameters:
destAbsPath - the location to which the node at srcAbsPathis to be copied in this workspace. the path of the node at its new position.
throws:
NoSuchWorkspaceException - if srcWorkspace does notexist or if the current Session does not have permission to access it.
throws:
ConstraintViolationException - if the operation would violate anode-type or other implementation-specific constraint
throws:
VersionException - if the parent node of destAbsPath isversionable and checked-in, or is non-versionable but its nearest versionable ancestor ischecked-in.
throws:
AccessDeniedException - if the current session does have permission to accesssrcWorkspace but otherwise does not have sufficient access rights tocomplete the operation.
throws:
PathNotFoundException - if the node at srcAbsPath in srcWorkspace orthe parent of destAbsPath in this workspace does not exist.
throws:
ItemExistsException - if a node already exists at destAbsPathand same-name siblings are not allowed.
throws:
LockException - if a lock prevents the copy.
throws:
RepositoryException - if the last element of destAbsPathhas an index or if another error occurs. |
| createActivity | | public Node createActivity(String title) throws UnsupportedRepositoryOperationException, RepositoryException(Code) | | This method creates a new nt:activity at an implementation-determined
location in the /jcr:system/jcr:activities subtree.
The repository may, but is not required to, use the title
as a hint for what to name the new activity node. The new activity
Node is returned.
The new node is persisted immediately and does not require a save.
An UnsupportedRepositoryOperationException is thrown if the
repository does not support activities.
A RepositoryException is thrown if another error occurs.
Parameters:
title - a String the new activity Node.
throws:
UnsupportedRepositoryOperationException - if the repsoitory does not support activities.
throws:
RepositoryException - if another error occurs.
since:
JCR 2.0 |
| createWorkspace | | public void createWorkspace(String name) throws AccessDeniedException, UnsupportedRepositoryOperationException, RepositoryException(Code) | | Creates a new Workspace with the specified
name. The new workspace is empty, meaning it contains only
root node.
The new workspace can be accessed through a login
specifying its name.
Throws an AccessDeniedException if the session through which
this Workspace object was acquired does not have permission
to create the new workspace.
Throws an UnsupportedRepositoryOperationException if the repository does
not support the creation of workspaces.
A RepositoryException is thrown if another error occurs.
Parameters:
name - A String, the name of the new workspace.
throws:
AccessDeniedException - if the session through whichthis Workspace object was acquired does not have permissionto create the new workspace.
throws:
UnsupportedRepositoryOperationException - if the repository doesnot support the creation of workspaces.
throws:
RepositoryException - if another error occurs.
since:
JCR 2.0 |
| createWorkspace | | public void createWorkspace(String name, String srcWorkspace) throws AccessDeniedException, UnsupportedRepositoryOperationException, RepositoryException(Code) | | Creates a new Workspace with the specified name
initialized with a clone of the content of the workspace
srcWorkspace. Semantically, this method is equivalent to
creating a new workspace and manually cloning srcWorkspace
to it; however, this method may assist some implementations in optimizing
subsequent Node.update and Node.merge calls
between the new workspace and its source.
The new workspace can be accessed through a login
specifying its name.
Throws an AccessDeniedException if the session through which
this Workspace object was acquired does not have permission
to create the new workspace.
Throws an UnsupportedRepositoryOperationException if the repository does
not support the creation of workspaces.
A RepositoryException is thrown if another error occurs.
Parameters:
name - A String, the name of the new workspace.
Parameters:
srcWorkspace - The name of the workspace from which the new workspace is to be cloned.
throws:
AccessDeniedException - if the session through whichthis Workspace object was acquired does not have permissionto create the new workspace.
throws:
UnsupportedRepositoryOperationException - if the repository doesnot support the creation of workspaces.
throws:
RepositoryException - if another error occurs.
since:
JCR 2.0 |
| deleteWorkspace | | public void deleteWorkspace(String name) throws AccessDeniedException, UnsupportedRepositoryOperationException, RepositoryException(Code) | | Deletes the workspace with the specified name from the
repository, deleting all content within it.
Throws an AccessDeniedException if the session through which
this Workspace object was acquired does not have permission
to remove the workspace.
Throws an UnsupportedRepositoryOperationException if the
repository does not support the removal of workspaces.
Parameters:
name - A String, the name of the workspace to be deleted.
throws:
AccessDeniedException - if the session through whichthis Workspace object was acquired does not have permissionto remove the workspace.
throws:
UnsupportedRepositoryOperationException - if therepository does not support the removal of workspaces.
throws:
RepositoryException - if another error occurs.
since:
JCR 2.0 |
| getAccessibleWorkspaceNames | | public String[] getAccessibleWorkspaceNames() throws RepositoryException(Code) | | Returns a string array containing the names of all workspaces
in this repository that are accessible to this user, given the
Credentials that were used to get the Session
to which this Workspace is tied.
In order to access one of the listed workspaces, the user performs another
Repository.login, specifying the name of the desired workspace,
and receives a new Session object.
string array of names of accessible workspaces.
throws:
RepositoryException - if an error occurs |
| getImportContentHandler | | public ContentHandler getImportContentHandler(String parentAbsPath, int uuidBehavior) throws PathNotFoundException, ConstraintViolationException, VersionException, LockException, AccessDeniedException, RepositoryException(Code) | | Returns an org.xml.sax.ContentHandler which can be used to push SAX events into the repository.
If the incoming XML stream (in the form of SAX events) does not appear to be a JCR system view XML document then it is
interpreted as a document view XML document.
The incoming XML is deserialized into a subtree of items immediately below the node at
parentAbsPath.
This method simply returns the ContentHandler without altering the state of the
repository; the actual deserialization is done through the methods of the ContentHandler.
Invalid XML data will cause the ContentHandler to throw a SAXException.
As SAX events are fed into the ContentHandler, changes are made directly at the
workspace level, without going through the Session. As a result, there is not need
to call save. The advantage of this
direct-to-workspace method is that a large import will not result in a large cache of pending
nodes in the Session. The disadvantage is that structures that violate node type constraints
cannot be imported, fixed and then saved. Instead, a constraint violation will cause the
ContentHandler to throw a SAXException. See Session.getImportContentHandler for a version of
this method that does go through the Session.
The flag uuidBehavior governs how the identifiers of incoming (deserialized) nodes are
handled. There are four options:
-
ImportUUIDBehavior.IMPORT_UUID_CREATE_NEW : Incoming nodes are assigned newly
created identifiers upon addition to the workspace. As a result identifier collisions never occur.
-
ImportUUIDBehavior.IMPORT_UUID_COLLISION_REMOVE_EXISTING : If an incoming node
has the same identifier as a node already existing in the workspace, then the already exisitng node
(and its subtree) is removed from wherever it may be in the workspace before the incoming node
is added. Note that this can result in nodes "disappearing" from locations in the workspace that
are remote from the location to which the incoming subtree is being written.
-
ImportUUIDBehavior.IMPORT_UUID_COLLISION_REPLACE_EXISTING : If an incoming node
has the same identifier as a node already existing in the workspace then the already existing node
is replaced by the incoming node in the same position as the existing node. Note that this may
result in the incoming subtree being disaggregated and "spread around" to different locations
in the workspace. In the most extreme case this behavior may result in no node at all
being added as child of
parentAbsPath. This will occur if the topmost element
of the incoming XML has the same identifier as an existing node elsewhere in the workspace.
-
ImportUUIDBehavior.IMPORT_UUID_COLLISION_THROW : If an incoming node
has the same identifier as a node already existing in the workspace then a
SAXException
is thrown by the returned ContentHandler during deserialization.
A SAXException will be thrown by the returned ContentHandler
during deserialization if the top-most element of the incoming XML would deserialize to
a node with the same name as an existing child of parentAbsPath and that
child does not allow same-name siblings.
A SAXException will also be thrown by the returned ContentHandler
during deserialzation if uuidBehavior is set to
IMPORT_UUID_COLLISION_REMOVE_EXISTING and an incoming node has the same identifier as
the node at parentAbsPath or one of its ancestors.
A PathNotFoundException is thrown if no node exists at parentAbsPath.
A ConstraintViolationException is thrown if the new subtree cannot be added to the node at
parentAbsPath due to node-type or other implementation-specific constraints, and this can
be determined before the first SAX event is sent. Unlike
Session.getImportContentHandler ,
this method also enforces node type constraints by throwing SAXExceptions during
deserialization. However, which node type constraints are enforced depends upon whether node type
information in the imported data is respected, and this is an implementation-specific issue.
A VersionException is thrown if the node at parentAbsPath is versionable
and checked-in, or is non-versionable but its nearest versionable ancestor is checked-in.
A LockException is thrown if a lock prevents the addition ofthe subtree.
An AccessDeniedException is thrown if the session associated with this Workspace object does not have
sufficient permissions to perform the import.
Parameters:
parentAbsPath - the absolute path of a node under which (as child) the imported subtree will be built.
Parameters:
uuidBehavior - a four-value flag that governs how incoming identifiers are handled. an org.xml.sax.ContentHandler whose methods may be called to feed SAX events into the deserializer.
throws:
PathNotFoundException - if no node exists at parentAbsPath.
throws:
ConstraintViolationException - if the new subtree cannot be added to the node atparentAbsPath due to node-type or other implementation-specific constraints,and this can be determined before the first SAX event is sent.
throws:
VersionException - if the node at parentAbsPath is versionableand checked-in, or is non-versionable but its nearest versionable ancestor is checked-in.
throws:
LockException - if a lock prevents the addition of the subtree.
throws:
AccessDeniedException - if the session associated with this Workspace object does not havesufficient permissions to perform the import.
throws:
RepositoryException - if another error occurs. |
| getName | | public String getName()(Code) | | Returns the name of the actual persistent workspace represented by this
Workspace object. This the name used in Repository.login.
the name of this workspace. |
| getNamespaceRegistry | | public NamespaceRegistry getNamespaceRegistry() throws RepositoryException(Code) | | Returns the NamespaceRegistry object, which is used to access the mapping between
prefixes and namespaces. In level 2 repositories the NamespaceRegistry can also be
used to change the namespace mappings.
throws:
RepositoryException - if an error occurs. the NamespaceRegistry. |
| getNodeTypeManager | | public NodeTypeManager getNodeTypeManager() throws RepositoryException(Code) | | Returns the NodeTypeManager through which node type
information can be queried. There is one node type registry per
repository, therefore the NodeTypeManager is not
workspace-specific; it provides introspection methods for the
global, repository-wide set of available node types. In
repositories that support it, the NodeTypeManager
can also be used to register new node types.
throws:
RepositoryException - if an error occurs. a NodeTypeManager object. |
| getSession | | public Session getSession()(Code) | | Returns the Session object through which this Workspace
object was acquired.
a Session object. |
| importXML | | public void importXML(String parentAbsPath, InputStream in, int uuidBehavior) throws IOException, PathNotFoundException, ItemExistsException, ConstraintViolationException, InvalidSerializedDataException, LockException, AccessDeniedException, RepositoryException(Code) | | Deserializes an XML document and adds the resulting item subtree as a child of the node at
parentAbsPath.
If the incoming XML stream does not appear to be a JCR system view XML document then it is interpreted as a
document view XML document.
The passed InputStream is closed before this method returns either
normally or because of an exception.
Changes are made directly at the workspace level, without going through the Session.
As a result, there is not need to call save. The advantage of this
direct-to-workspace method is that a large import will not result in a large cache of
pending nodes in the Session. The disadvantage is that invalid data cannot
be imported, fixed and then saved. Instead, invalid data will cause this method to throw an
InvalidSerializedDataException. See Session.importXML for
a version of this method that does go through the Session.
The flag uuidBehavior governs how the identifiers of incoming (deserialized) nodes are
handled. There are four options:
-
ImportUUIDBehavior.IMPORT_UUID_CREATE_NEW : Incoming nodes are assigned newly
created identifiers upon additon to the workspace. As a result identifier collisions never occur.
-
ImportUUIDBehavior.IMPORT_UUID_COLLISION_REMOVE_EXISTING : If an incoming node
has the same identifier as a node already existing in the workspace then the already exisitng node
(and its subtree) is removed from wherever it may be in the workspace before the incoming node
is added. Note that this can result in nodes "disappearing" from locations in the workspace that
are remote from the location to which the incoming subtree is being written. If an incoming node
has the same identifier as the existing root node of this workspace then
-
ImportUUIDBehavior.IMPORT_UUID_COLLISION_REPLACE_EXISTING : If an incoming node
has the same identifier as a node already existing in the workspace then the already existing node
is replaced by the incoming node in the same position as the existing node. Note that this may
result in the incoming subtree being disaggregated and "spread around" to different locations
in the workspace. In the most extreme edge case this behavior may result in no node at all
being added as child of
parentAbsPath. This will occur if the topmost element
of the incoming XML has the same identifier as an existing node elsewhere in the workspace.
-
ImportUUIDBehavior.IMPORT_UUID_COLLISION_THROW : If an incoming node
has the same identifier as a node already existing in the workspace then an
ItemExistsException
is thrown.
An ItemExistsException will be thrown if the top-most element
of the incoming XML would deserialize to a node with the same name as an
existing child of parentAbsPath and that child does not allow
same-name siblings.
An IOException is thrown if an I/O error occurs.
If no node exists at parentAbsPath, a PathNotFoundException is thrown.
If node-type or other implementation-specific constraints prevent the
addition of the subtree, a ConstraintViolationException is
thrown.
A ConstraintViolationException will also be thrown if
uuidBehavior is set to IMPORT_UUID_COLLISION_REMOVE_EXISTING
and an incoming node has the same identifier as the node at parentAbsPath
or one of its ancestors.
A VersionException is thrown if the node at parentAbsPath is versionable
and checked-in, or is non-versionable but its nearest versionable ancestor is checked-in.
A LockException is thrown if a lock prevents the addition of the subtree.
An AccessDeniedException is thrown if the session associated with this Workspace object does not have
sufficient permissions to perform the import.
Parameters:
parentAbsPath - the absolute path of the node below which the deserialized subtree is added.
Parameters:
in - The Inputstream from which the XML to be deserilaized is read.
Parameters:
uuidBehavior - a four-value flag that governs how incoming identifiers are handled.
throws:
java.io.IOException - if an error during an I/O operation occurs.
throws:
PathNotFoundException - if no node exists at parentAbsPath.
throws:
ConstraintViolationException - if node-type or other implementation-specific constraintsprevent the addition of the subtree or if uuidBehavioris set to IMPORT_UUID_COLLISION_REMOVE_EXISTING and an incoming node has the sameidentifier as the node at parentAbsPath or one of its ancestors.
throws:
VersionException - if the node at parentAbsPath is versionableand checked-in, or is non-versionable but its nearest versionable ancestor is checked-in.
throws:
InvalidSerializedDataException - if incoming stream is not a valid XML document.
throws:
ItemExistsException - if the top-most element of the incoming XML would deserializeto a node with the same name as an existing child of parentAbsPath and thatchild does not allow same-name siblings, or if a uuidBehavior is set toIMPORT_UUID_COLLISION_THROW and an identifier collision occurs.
throws:
LockException - if a lock prevents the addition of the subtree.
throws:
AccessDeniedException - if the session associated with this Workspace object does not havesufficient permissions to perform the import.
throws:
RepositoryException - is another error occurs. |
| merge | | public NodeIterator merge(Node activityNode) throws VersionException, AccessDeniedException, MergeException, LockException, InvalidItemStateException, RepositoryException(Code) | | This method merges the changes that were made under the specified
activity into this workspace.
An activity A will be associated with a set of versions through the
jcr:activity reference of each version node in the set.
We call each such associated version a member of A.
For each version history H that contains one or more members of
A, one such member will be the latest member of A in H.
The latest member of A in H is the version in H that
is a member of A and that has no successor versions (to any degree)
that are also members of A.
The set of versions that are the latest members of A in their
respective version histories is called the change set of A. It
fully describes the changes made under the activity A.
This method performs a shallow merge into this workspace of each version
in the change set of the activity specified by activityNode.
If there is no corresponding node in this workspace for a given member of
the change set, that member is ignored.
This method returns a NodeIterator over all versionable
nodes in the subtree that received a merge result of fail.
A VersionException is thrown if the specified node is not
an nt:activity node.
A MergeException is thrown in the same cases as in a regular
shallow merge (see
Node.merge(Stringbooleanboolean) ).
If the current session does not have sufficient permissions to perform
the operation, then an AccessDeniedException is thrown.
An InvalidItemStateException is thrown if this Session
has pending unsaved changes.
A LockException is thrown if a lock prevents the merge.
An UnsupportedRepositoryOperationException is thrown if
this operation is not supported by this implementation.
A RepositoryException is thrown if another error occurs.
Parameters:
activityNode - an nt:activity node a NodeIterator
throws:
AccessDeniedException - if the current session does not have sufficientrights to perform the operation.
throws:
VersionException - if the specified node is not an nt:activity node.
throws:
MergeException - in the same cases as in a regular shallow merge(see Node.merge(Stringbooleanboolean)).
throws:
LockException - if a lock prevents the merge.
throws:
InvalidItemStateException - if this Session has pending unsaved changes.
throws:
RepositoryException - if another error occurs.
since:
JCR 2.0 |
| move | | public String move(String srcAbsPath, String destAbsPath) throws ConstraintViolationException, VersionException, AccessDeniedException, PathNotFoundException, ItemExistsException, LockException, RepositoryException(Code) | | Moves the node at srcAbsPath (and its entire subtree) to the
new location at destAbsPath. Returns the path of the node at
its new position. Note that the returned path will indicate the resulting
same-name sibling index of the destination, if necessary, unlike the
supplied destAbsPath parameter (see below).
If successful,
the change is persisted immediately, there is no need to call save.
Note that this is in contrast to
Session.move which operates within the
transient space and hence requires a save.
The identifiers of referenceable nodes must not be changed by a move.
The identifiers of non-referenceable nodes may change.
The destAbsPath provided must not
have an index on its final element. If it does then a RepositoryException
is thrown. Strictly speaking, the destAbsPath parameter is actually an absolute path
to the parent node of the new location, appended with the new name desired for the
moved node. It does not specify a position within the child node
ordering. If ordering is supported by the node type of
the parent node of the new location, then the newly moved node is appended to the end of the
child node list. The resulting position within a same-name sibling set can,
however, be determined from the path returned by this method,
which will include an index if one is required.
This method cannot be used to move just an individual property by itself.
It moves an entire node and its subtree (including, of course, any properties contained therein).
The identifiers of referenceable nodes must not be changed by a move.
The identifiers of non-referenceable nodes may change.
A ConstraintViolationException is thrown if the operation would violate a node-type
or other implementation-specific constraint.
A VersionException is thrown if the parent node of destAbsPath
or the parent node of srcAbsPath is versionable and checked-in, or is
non-versionable but its nearest versionable ancestor is checked-in.
An AccessDeniedException is thrown if the current session (i.e. the session that
was used to acquire this Workspace object) does not have sufficient access rights
to complete the operation.
A PathNotFoundException is thrown if the node at srcAbsPath or the
parent of destAbsPath does not exist.
An ItemExistException is thrown if a node already exists at
destAbsPath and same-name siblings are not allowed.
Note that if a property already exists at destAbsPath, the
operation succeeds, since a node may have a child node and property with
the same name
A LockException if a lock prevents the move.
Parameters:
srcAbsPath - the path of the node to be moved.
Parameters:
destAbsPath - the location to which the node at srcAbsPathis to be moved. the path of the node at its new position.
throws:
ConstraintViolationException - if the operation would violate anode-type or other implementation-specific constraint
throws:
VersionException - if the parent node of destAbsPathor the parent node of srcAbsPath is versionable and checked-in,or is non-versionable but its nearest versionable ancestor is checked-in.
throws:
AccessDeniedException - if the current session (i.e. the session thatwas used to aqcuire this Workspace object) does not havesufficient access rights to complete the operation.
throws:
PathNotFoundException - if the node at srcAbsPath orthe parent of destAbsPath does not exist.
throws:
ItemExistsException - if a node already exists atdestAbsPath and same-name siblings are not allowed.
throws:
LockException - if a lock prevents the move.
throws:
RepositoryException - if the last element of destAbsPathhas an index or if another error occurs. |
| restore | | public void restore(Version[] versions, boolean removeExisting) throws ItemExistsException, UnsupportedRepositoryOperationException, VersionException, LockException, InvalidItemStateException, RepositoryException(Code) | | Restores a set of versions at once. Used in cases where a "chicken and egg" problem of
mutually referring REFERENCE properties would prevent the restore in any
serial order.
If the restore succeeds the changes made to this node are
persisted immediately, there is no need to call save.
The following restrictions apply to the set of versions specified:
If S is the set of versions being restored simultaneously,
-
For every version
V in S that corresponds to
a missing node, there must also be a parent of V in S.
-
S must contain at least one version that corresponds to
an existing node in the workspace.
-
No
V in S can be a root version (jcr:rootVersion).
If any of these restrictions does not hold, the restore will fail
because the system will be unable to determine the path locations to which
one or more versions are to be restored. In this case a
VersionException is thrown.
The versionable nodes in this workspace that correspond to the versions being restored
define a set of (one or more) subtrees. An identifier collision occurs when this workspace
contains a node outside these subtrees that has the same identifier as one of the nodes
that would be introduced by the restore operation into one of these subtrees.
The result in such a case is governed by the removeExisting flag.
If removeExisting is true then the incoming node takes precedence,
and the existing node (and its subtree) is removed. If removeExisting
is false then a ItemExistsException is thrown and no changes are made.
Note that this applies not only to cases where the restored
node itself conflicts with an existing node but also to cases where a conflict occurs with any
node that would be introduced into the workspace by the restore operation. In particular, conflicts
involving subnodes of the restored node that have OnParentVersion settings of
COPY or VERSION are also governed by the removeExisting flag.
An UnsupportedRepositoryOperationException is thrown if one or more of the nodes to be restored
is not versionable.
An InvalidItemStateException is thrown if this Session
has pending unsaved changes.
A LockException is thrown if a lock prevents the restore.
Parameters:
versions - The set of versions to be restored
Parameters:
removeExisting - governs what happens on identifier collision.
throws:
ItemExistsException - if removeExisting is falseand an identifier collision occurs with a node being restored.
throws:
UnsupportedRepositoryOperationException - if one or more of the nodes to berestored is not versionable.
throws:
VersionException - if the set of versions to be restored is such that theoriginal path location of one or more of the versions cannot be determined orif the restore would change the state of a existing verisonablenode that is currently checked-in or if a root version (jcr:rootVersion)is among those being restored.
throws:
LockException - if a lock prevents the restore.
throws:
InvalidItemStateException - if this Session has pending unsaved changes.
throws:
RepositoryException - if another error occurs. |
|
|