Java Doc for Node.java in  » 6.0-JDK-Modules » jsr-283 » javax » jcr » Java Source Code / Java DocumentationJava Source Code and Java Documentation

An ItemExistsException will be thrown either immediately (by this method), or on save, if an item at the specified path already exists and same-name siblings are not allowed.

Cancels the merge process with respect to this node and specified version.

See Node.doneMerge for a full explanation.

If this node is already checked-in, this method is equivalent to checkout().

If this node is not versionable, an UnsupportedRepositoryOperationException is thrown.

A VersionException is thrown if a child item of this node has an OnParentVersion of ABORT.

Completes the merge process with respect to this node and the specified version.

When the Node.merge method is called on a node, every versionable node in that subtree is compared with its corresponding node in the indicated other workspace and a "merge test result" is determined indicating one of the following:

1. This node will be updated to the state of its correspondee (if the base version of the correspondee is more recent in terms of version history)
2. This node will be left alone (if this node's base version is more recent in terms of version history).
3. This node will be marked as having failed the merge test (if this node's base version is on a different branch of the version history from the base version of its corresponding node in the other workspace, thus preventing an automatic determination of which is more recent).

In the last case the merge of the non-versionable subtree (the "content") of this node must be done by the application (for example, by providing a merge tool for the user).

Additionally, once the content of the nodes has been merged, their version graph branches must also be merged.

This method may change the value of the jcr:currentLifecycleState property, in most cases it is expected that the implementation will change the value to that of the passed transition parameter, though this is an implementation-specific issue.

If no corresponding node exists then an ItemNotFoundException is thrown.

If the specified workspace does not exist then a NoSuchWorkspaceException is thrown.

If the current Session does not have sufficent rights to perform this operation, an AccessDeniedException is thrown.
Parameters:
  workspaceName - the name of the workspace.

If relPath contains a path element that refers to a node with same-name sibling nodes without explicitly including an index using the array-style notation ([x]), then the index [1] is assumed (indexing of same name siblings begins at 1, not 0, in order to preserve compatibility with XPath).

Within the scope of a single Session object, if a Node object has been acquired, any subsequent call of getNode reacquiring the same node must return a Node object reflecting the same state as the earlier Node object.

If the name parameter is null then all referring REFERENCES are returned regardless of name.

Some level 2 implementations may only return properties that have been saved (in a transactional setting this includes both those properties that have been saved but not yet committed, as well as properties that have been committed).

If the name parameter is null then all referring WEAKREFERENCE are returned regardless of name.

Some level 2 implementations may only return properties that have been saved (in a transactional setting this includes both those properties that have been saved but not yet committed, as well as properties that have been committed).

• versionable (full or simple) and currently checked-out,
• non-versionable and its nearest versionable ancestor is checked-out or
• non-versionable and it has no versionable ancestor.

This method can be thought of as a version-sensitive update.

It recursively tests each versionable node in the subtree of this node against its corresponding node in srcWorkspace with respect to the relation between their respective base versions and either updates the node in question or not, depending on the outcome of the test.

A MergeException is thrown if bestEffort is false and a versionable node is encountered whose corresponding node's base version is on a divergent branch from this node's base version.

If successful, the changes are persisted immediately, there is no need to call save.

This method returns a NodeIterator over all versionable nodes in the subtree that received a merge result of fail.

This method can be thought of as a version-sensitive update.

If isShallow is true, it tests this versionable node against its corresponding node in srcWorkspace with respect to the relation between their respective base versions and either updates the node in question or not, depending on the outcome of the test.

If isShallow is false, it recursively tests each versionable node in the subtree as mentioned above.

If isShallow is true and this node is not versionable, then this method returns and no changes are made.

A MergeException is thrown if bestEffort is false and a versionable node is encountered whose corresponding node's base version is on a divergent branch from this node's base version.

If successful, the changes are persisted immediately, there is no need to call save.

This method returns a NodeIterator over all versionable nodes in the subtree that received a merge result of fail.

To place the node srcChildRelPath at the end of the list, a destChildRelPath of null is used.

Note that (apart from the case where destChildRelPath is null) both of these arguments must be relative paths of depth one, in other words they are the names of the child nodes, possibly suffixed with an index.

If srcChildRelPath and destChildRelPath are the same, then no change is made.

Changes to ordering of child nodes are persisted on save of the parent node.

All of the exceptions defined for remove() apply to this function.

If this node is not versionable, an UnsupportedRepositoryOperationException is thrown.

If successful, the change is persisted immediately and there is no need to call save.

A VersionException is thrown if no version with the specified versionName exists in this node's version history or if an attempt is made to restore the root version (jcr:rootVersion).

An InvalidItemStateException is thrown if this Session (not necessarily this Node) has pending unsaved changes.

A LockException is thrown if a lock prevents the addition of the mixin.

This method will work regardless of whether this node is checked-in or not.

An identifier collision occurs when a node exists outside the subtree rooted at this node with the same identifier as a node that would be introduced by the restore operation into the subtree at this node.

If this node is not versionable, an UnsupportedRepositoryOperationException is thrown.

If successful, the change is persisted immediately and there is no need to call save.

A VersionException is thrown if the specified version is not part of this node's version history or if an attempt is made to restore the root version (jcr:rootVersion).

An InvalidItemStateException is thrown if this Session (not necessarily this Node) has pending unsaved changes.

A LockException is thrown if a lock prevents the restore.

This method will work regardless of whether this node is checked-in or not.

An identifier collision occurs when a node exists outside the subtree rooted at this node with the same identifier as a node that would be introduced by the restore operation into the subtree at this node.

A node need not exist at relPath, though the parent of relPath must exist, otherwise a PathNotFoundException is thrown.

If a node does exist at relPath then it must correspond to the version being restored (the version must be a version of that node) and must not be a root version (jcr:rootVersion), otherwise a VersionException is thrown.

If no node exists at relPath then a VersionException is thrown if the parent node of relPath is versionable and checked-in or is non-versionable but its nearest versionable ancestor is checked-in.

If there is a node at relPath then the checked-in status of that node itself and the checked-in status of its parent are irrelevant.

A VersionException is thrown if the specified versionLabel does not exist in this node's version history.

An InvalidItemStateException is thrown if this Session (not necessarily this Node) has pending unsaved changes.

A LockException is thrown if a lock prevents the restore.

This method will work regardless of whether this node is checked-in or not.

An identifier collision occurs when a node exists outside the subtree rooted at this node with the same identifier as a node that would be introduced by the restoreByLabel operation into the subtree at this node.

The supplied holdID is added to the jcr:hold multi-value property and the corresponding jcr:isDeep value is set accordingly.

The type of the new property is determined by the type parameter specified.

If the property type of the supplied Value object is different from that required, then a best-effort conversion is attempted.

The type of the property is determined by the type parameter specified.

If the property type specified is not PropertyType.STRING, then a best-effort conversion is attempted.

A ConstraintViolationException is thrown either immediately or on save if a conflict with another assigned mixin or the primary node type or for an implementation-specific reason. Implementations may differ on when this validation is done.

In some implementations it may only be possible to add mixin types before a a node is first saved, and not after. I such cases any later calls to addMixin will throw a ConstraintViolationException either immediately or on save.

A NoSuchNodeTypeException is thrown either immediately or on save if the specified mixinName is not recognized. Implementations may differ on when this validation is done.

A VersionException is thrown either immediately or on save if this node is versionable and checked-in or is non-versionable but its nearest versionable ancestor is checked-in. Implementations may differ on when this validation is done.

A LockException is thrown either immediately or on save if a lock prevents the addition of the mixin. Implementations may differ on when this validation is done.
Parameters:
  mixinName - the name of the mixin node type to be added
throws:
  NoSuchNodeTypeException - If the specified mixinNameis not recognized and thisimplementation performs this validation immediately instead of waiting until save.
throws:
  ConstraintViolationException - If the specified mixin node typeis prevented from being assigned.
throws:
  VersionException - if this node is versionable and checked-in or is non-versionable but itsnearest versionable ancestor is checked-in and thisimplementation performs this validation immediately instead of waiting until save..
throws:
  LockException - if a lock prevents the addition of the mixin and thisimplementation performs this validation immediately instead of waiting until save.
throws:
  RepositoryException - if another error occurs.

In order to save a newly added node, save must be called either on the Session, or on the new node's parent or higher-order ancestor (grandparent, etc.). An attempt to call save only on the newly added node will throw a RepositoryException.

In the context of this method the relPath provided must not have an index on its final element. If it does then a RepositoryException is thrown.

Strictly speaking, the parameter is actually a relative path to the parent node of the node to be added, appended with the name desired for the new node (if the a node is being added directly below this node then only the name need be specified). It does not specify a position within the child node ordering. If ordering is supported by the node type of the parent node then the new node is appended to the end of the child node list.

Since this signature does not allow explicit node type assignment, the new node's primary node type will be determined (either immediately or on save, depending on the implementation) by the child node definitions in the node types of its parent.

An ItemExistsException will be thrown either immediately (by this method), or on save, if an item at the specified path already exists and same-name siblings are not allowed. Implementations may differ on when this validation is performed.

A PathNotFoundException will be thrown either immediately, or on save, if the specified path implies intermediary nodes that do not exist. Implementations may differ on when this validation is performed.

A ConstraintViolationException will be thrown either immediately or on save if adding the node would violate a node type or implementation-specific constraint or if an attempt is made to add a node as the child of a property. Implementations may differ on when this validation is performed.

A VersionException will be thrown either immediately or on save, if the node to which the new child is being added is versionable and checked-in or is non-versionable but its nearest versionable ancestor is checked-in. Implementations may differ on when this validation is performed.

A LockException will be thrown either immediately (by this method), or on save, if a lock prevents the addition of the node. Implementations may differ on when this validation is performed.
Parameters:
  relPath - The path of the new node to be created. The node that was added.
throws:
  ItemExistsException - if an item at the specified path already exists,same-name siblings are not allowed and this implementation performs thisvalidation immediately instead of waiting until save.
throws:
  PathNotFoundException - if the specified path implies intermediaryNodes that do not exist or the last element ofrelPath has an index, and this implementation performs thisvalidation immediately instead of waiting until save.
throws:
  ConstraintViolationException - if a node type or implementation-specific constraintis violated or if an attempt is made to add a node as the child of a property and thisimplementation performs this validation immediately instead of waiting until save.
throws:
  VersionException - if the node to which the new child is being added is versionable andchecked-in or is non-versionable but its nearest versionable ancestor is checked-in and thisimplementation performs this validation immediately instead of waiting until save.
throws:
  LockException - if a lock prevents the addition of the node and thisimplementation performs this validation immediately instead of waiting until save.
throws:
  RepositoryException - If the last element of relPath has an index or if another error occurs.

An ItemExistsException will be thrown either immediately (by this method), or on save, if an item at the specified path already exists and same-name siblings are not allowed. Implementations may differ on when this validation is performed.

A PathNotFoundException will be thrown either immediately, or on save, if the specified path implies intermediary nodes that do not exist. Implementations may differ on when this validation is performed.

A NoSuchNodeTypeException will be thrown either immediately or on save, if the specified node type is not recognized. Implementations may differ on when this validation is performed.

A ConstraintViolationException will be thrown either immediately or on save if adding the node would violate a node type or implementation-specific constraint or if an attempt is made to add a node as the child of a property. Implementations may differ on when this validation is performed.

A VersionException will be thrown either immediately or on save, if the node to which the new child is being added is versionable and checked-in or is non-versionable but its nearest versionable ancestor is checked-in. Implementations may differ on when this validation is performed.

A LockException will be thrown either immediately (by this method), or on save, if a lock prevents the addition of the node. Implementations may differ on when this validation is performed.
Parameters:
  relPath - the path of the new node to be created.
Parameters:
  primaryNodeTypeName - The name of the primary node type of the new node. the node that was added.
throws:
  ItemExistsException - if an item at the specified path already exists,same-name siblings are not allowed and this implementation performs thisvalidation immediately instead of waiting until save.
throws:
  PathNotFoundException - if the specified path implies intermediaryNodes that do not exist or the last element ofrelPath has an index, and this implementation performs thisvalidation immediately instead of waiting until save.
throws:
  NoSuchNodeTypeException - if the specified node type is not recognized and thisimplementation performs this validation immediately instead of waiting until save.
throws:
  ConstraintViolationException - if a node type or implementation-specific constraintis violated or if an attempt is made to add a node as the child of a property and thisimplementation performs this validation immediately instead of waiting until save.
throws:
  VersionException - if the node to which the new child is being added is versionable andchecked-in or is non-versionable but its nearest versionable ancestor is checked-in and thisimplementation performs this validation immediately instead of waiting until save.
throws:
  LockException - if a lock prevents the addition of the node and thisimplementation performs this validation immediately instead of waiting until save.
throws:
  RepositoryException - if the last element of relPath has an index or ifanother error occurs.

• The mixin's definition conflicts with an existing primary or mixin node type of this node.
• This node is versionable and checked-in or is non-versionable and its nearest versionable ancestor is checked-in.
• This node is protected (as defined in this node's NodeDefinition, found in the node type of this node's parent).
• An access control restriction would prevent the addition of the mixin.
• A lock would prevent the addition of the mixin.
• An implementation-specific restriction would prevent the addition of the mixin.

Cancels the merge process with respect to this node and specified version.

See Node.doneMerge for a full explanation. Also see Node.merge for more details.

If successful, these changes are persisted immediately, there is no need to call save.

A VersionException is thrown if the version specified is not among those referenced in this node's jcr:mergeFailed property or if this node is currently checked-in.

An UnsupportedRepositoryOperationException is thrown if this nod is not versionable.

If there are unsaved changes pending on this node, an InvalidItemStateException is thrown.

A RepositoryException is thrown if another error occurs.
Parameters:
  version - a version referred to by this node's jcr:mergeFailed property.
throws:
  VersionException - if the version specified is not among those referenced in this node's jcr:mergeFailed or if this node is currently checked-in.
throws:
  InvalidItemStateException - if there are unsaved changes pending on this node.
throws:
  UnsupportedRepositoryOperationException - if this node is not versionable.
throws:
  RepositoryException - if another error occurs.

Read-only status means that an item cannot be altered by the client using standard API methods (addNode, setProperty, etc.). The only exceptions to this rule are the Node.restore (all signatures), Node.restoreByLabel , Workspace.restore , Node.merge and Node.update operations; these do not respect read-only status due to check-in. Note that remove of a read-only node is possible, as long as its parent is not read-only (since removal is an alteration of the parent node).

If this node is already checked-in, this method has no effect but returns the current base version of this node.

If this node is not versionable, an UnsupportedRepositoryOperationException is thrown.

A VersionException is thrown or if a child item of this node has an OnParentVersion status of ABORT. This includes the case where an unresolved merge failure exists on this node, as indicated by the presence of the jcr:mergeFailed property.

If there are unsaved changes pending on this node, an InvalidItemStateException is thrown.

Throws a LockException if a lock prevents the operation.

If checkin succeeds, the change to the jcr:isCheckedOut property is automatically persisted (there is no need to do an additional save).

a Version object
throws:
  VersionException - if jcr:predecessors does not contain at least one value or ifa child item of this node has an OnParentVersion status of ABORT.This includes the case where an unresolved merge failure exists on this node, as indicatedby the presence of a jcr:mergeFailed property.
throws:
  UnsupportedRepositoryOperationException - If this node is not versionable.
throws:
  InvalidItemStateException - If unsaved changes exist on this node.
throws:
  LockException - if a lock prevents the operation.
throws:
  RepositoryException - If another error occurs.

This method puts the node into the checked-out state, making it and its connected non-versionable subtree no longer read-only (see Node.checkin() for an explanation of the term "connected non-versionable subtree". Under simple versioning this will simply be the whole subtree).

If successful, these changes are persisted immediately, there is no need to call save.

If this node is already checked-out, this method has no effect.

Throws a LockException if a lock prevents the checkout.
throws:
  UnsupportedRepositoryOperationException - If this node is not versionable.
throws:
  LockException - if a lock prevents the checkout.
throws:
  RepositoryException - If another error occurs.

If this node is already checked-in, this method is equivalent to checkout().

If this node is not versionable, an UnsupportedRepositoryOperationException is thrown.

A VersionException is thrown if a child item of this node has an OnParentVersion of ABORT. This includes the case where an unresolved merge failure exists on this node, as indicated by the presence of the jcr:mergeFailed property.

If there are unsaved changes pending on this node, an InvalidItemStateException is thrown.

A LockException is thrown if a lock prevents the operation.

A RepositoryException is thrown if another error occurs.
throws:
  VersionException - if a child item of this node has anOnParentVersion of ABORT. This includes the casewhere an unresolved merge failure exists on this node, as indicated bythe presence of the jcr:mergeFailed.
throws:
  UnsupportedRepositoryOperationException - if this node is not versionable.
throws:
  InvalidItemStateException - if there are unsaved changes pending on this node.
throws:
  LockException - if a lock prevents the operation.
throws:
  RepositoryException - if another error occurs.
since:
   JCR 2.0

If the specified baseline is null, a new version history is created to store baselines of the new configuration, and the jcr:baseVersion of the new configuration references the root of the new version history. If the specified baseline is not null, the jcr:baseVersion of the new configuration references the specified baseline.

The changes are persisted immediately, a save is not required.

An UnsupportedRepositoryOperationException is thrown if N is not versionable.

A RepositoryException is thrown if another error occurs.
Parameters:
  baseline - a Version a new nt:configuration node
throws:
  UnsupportedRepositoryOperationException - if N is not versionable.
throws:
  RepositoryException - if another error occurs.
since:
   JCR 2.0

Completes the merge process with respect to this node and the specified version.

When the Node.merge method is called on a node, every versionable node in that subtree is compared with its corresponding node in the indicated other workspace and a "merge test result" is determined indicating one of the following:

1. This node will be updated to the state of its correspondee (if the base version of the correspondee is more recent in terms of version history)
2. This node will be left alone (if this node's base version is more recent in terms of version history).
3. This node will be marked as having failed the merge test (if this node's base version is on a different branch of the version history from the base version of its corresponding node in the other workspace, thus preventing an automatic determination of which is more recent).

In the last case the merge of the non-versionable subtree (the "content") of this node must be done by the application (for example, by providing a merge tool for the user).

Additionally, once the content of the nodes has been merged, their version graph branches must also be merged. The JCR versioning system provides for this by keeping a record, for each versionable node that fails the merge test, of the base verison of the corresponding node that caused the merge failure. This record is kept in the jcr:mergeFailed property of this node. After a merge, this property will contain one or more (if multiple merges have been performed) REFERENCEs that point to the "offending versions".

To complete the merge process, the client calls doneMerge(Version v) passing the version object referred to be the jcr:mergeFailed property that the client wishes to connect to this node in the version graph. This has the effect of moving the reference to the indicated version from the jcr:mergeFailed property of this node to the jcr:predecessors.

If the client chooses not to connect this node to a particular version referenced in the jcr:mergeFailed property, he calls Node.cancelMerge(Version version) . This has the effect of removing the reference to the specified version from jcr:mergeFailed without adding it to jcr:predecessors.

Once the last reference in jcr:mergeFailed has been either moved to jcr:predecessors (with doneMerge) or just removed from jcr:mergeFailed (with cancelMerge) the jcr:mergeFailed property is automatically removed, thus enabling this node to be checked-in, creating a new version (note that before the jcr:mergeFailed is removed, its OnParentVersion setting of ABORT prevents checkin). This new version will have a predecessor connection to each version for which doneMerge was called, thus joining those branches of the version graph.

If successful, these changes are persisted immediately, there is no need to call save.

A VersionException is thrown if the version specified is not among those referecned in this node's jcr:mergeFailed property.

If there are unsaved changes pending on this node, an InvalidItemStateException is thrown.

An UnsupportedRepositoryOperationException is thrown if this node is not versionable.

A RepositoryException is thrown if another error occurs.
Parameters:
  version - a version referred to by this node's jcr:mergeFailed property.
throws:
  VersionException - if the version specifed is not among those referenced in this node's jcr:mergeFailed or if this node is currently checked-in.
throws:
  InvalidItemStateException - if there are unsaved changes pending on this node.
throws:
  UnsupportedRepositoryOperationException - if this node is not versionable.
throws:
  RepositoryException - if another error occurs.

This method may change the value of the jcr:currentLifecycleState property, in most cases it is expected that the implementation will change the value to that of the passed transition parameter, though this is an implementation-specific issue. If the jcr:currentLifecycleState property is changed the change is persisted immediately, there is no need to call save.

Throws an UnsupportedRepositoryOperationException if this implementation does not support lifecycle actions or if this node does not have the mix:lifecycle mixin.

Throws InvalidLifecycleTransitionException if the lifecycle transition is not successful.
Parameters:
  transition - a state transition
throws:
  UnsupportedRepositoryOperationException - if this implementation doesnot support lifecycle actions or if this node does not have themix:lifecycle mixin.
throws:
  InvalidLifecycleTransitionException - if the lifecycle transition is not successful.
throws:
  RepositoryException - if another error occurs.
since:
   JCR 2.0

If this node is not versionable, an UnsupportedRepositoryOperationException is thrown. a Version object.
throws:
  UnsupportedRepositoryOperationException - if this node is not versionable.
throws:
  RepositoryException - If another error occurs.

If no corresponding node exists then an ItemNotFoundException is thrown.

If the specified workspace does not exist then a NoSuchWorkspaceException is thrown.

If the current Session does not have sufficent rights to perform this operation, an AccessDeniedException is thrown.
Parameters:
  workspaceName - the name of the workspace. the absolute path to the corresponding node.
throws:
  ItemNotFoundException - if no corresponding node is found.
throws:
  NoSuchWorkspaceException - if the workspace is unknown.
throws:
  AccessDeniedException - if the current session has insufficent rights to perform this operation.
throws:
  RepositoryException - if another error occurs.

A RepositoryException is thrown if an error occurs. the identifier of this node
throws:
  RepositoryException - If an error occurs.
since:
   JCR 2.0

If the current session holds the lock token for this lock, then the returned Lock object contains that lock token (accessible through Lock.getLockToken). If this Session does not hold the applicable lock token, then the returned Lock object will not contain the lock token (its Lock.getLockToken method will return null).

If this node is not locked (no lock applies to this node), a LockException is thrown.

If the current session does not have sufficient privileges to get the lock, an AccessDeniedException is thrown.

An UnsupportedRepositoryOperationException is thrown if this implementation does not support locking.

A RepositoryException is thrown if another error occurs. The applicable Lock object, without a contained lock token.
throws:
  UnsupportedRepositoryOperationException - if this implementation does not support locking.
throws:
  LockException - if no lock applies to this node.
throws:
  AccessDeniedException - if the curent session does not have pernmission to get the lock.
throws:
  RepositoryException - if another error occurs.

If relPath contains a path element that refers to a node with same-name sibling nodes without explicitly including an index using the array-style notation ([x]), then the index [1] is assumed (indexing of same name siblings begins at 1, not 0, in order to preserve compatibility with XPath).

Within the scope of a single Session object, if a Node object has been acquired, any subsequent call of getNode reacquiring the same node must return a Node object reflecting the same state as the earlier Node object. Whether this object is actually the same Node instance, or simply one wrapping the same state, is up to the implementation.

If no node exists at relPath a PathNotFoundException is thrown. This exception is also thrown if the current Session does not have read access to the specified node.
Parameters:
  relPath - The relative path of the node to retrieve. The node at relPath.
throws:
  PathNotFoundException - If no node exists at the specified path or the current Session doesnot read access to the node at the specified path.
throws:
  RepositoryException - If another error occurs.

N.getNodes("jcr:* | myapp:report | my doc")

would return a NodeIterator holding all accessible child nodes of N that are either called 'myapp:report', begin with the prefix 'jcr:' or are called 'my doc'.

Note that leading and trailing whitespace around a disjunct is ignored, but whitespace within a disjunct forms part of the pattern to be matched.

The EBNF for namePattern is:

namePattern ::= disjunct {'|' disjunct}
disjunct ::= name [':' name]
name ::= '*' | ['*'] fragment {'*' fragment} ['*']
fragment ::= char {char}
char ::= nonspace | ' '
nonspace ::= Any XML Char (See http://www.w3.org/TR/REC-xml/) except: '/', ':', '[', ']', '*', ''', '"', '|' or any whitespace character

The pattern is matched against the names (not the paths) of the immediate child nodes of this node.

If this node has no accessible matching child nodes, then an empty iterator is returned.

The same reacquisition semantics apply as with Node.getNode(String) .
Parameters:
  namePattern - a name pattern a NodeIterator
throws:
  RepositoryException - If an unexpected error occurs.

In cases where the primary child item specifies the name of a set same-name sibling child nodes, the node returned will be the one among the same-name siblings with index [1].

The same reacquisition semantics apply as with Node.getNode(String) .

If this node does not have a primary item, either because none is declared in the node type or because a declared primary item is not present on this node instance, or not accessible through the current Session, then this method throws an ItemNotFoundException. the primary child item.
throws:
  ItemNotFoundException - if this node does not have a primarychild item, either because none is declared in the node type orbecause a declared primary item is not present on this node instance,or not accessible through the current Session
throws:
  RepositoryException - if another error occurs.

N.getProperties("jcr:* | myapp:name | my doc")

would return a PropertyIterator holding all accessible properties of N that are either called 'myapp:name', begin with the prefix 'jcr:' or are called 'my doc'.

Note that leading and trailing whitespace around a disjunct is ignored, but whitespace within a disjunct forms part of the pattern to be matched.

The EBNF for namePattern is:

namePattern ::= disjunct {'|' disjunct}
disjunct ::= name [':' name]
name ::= '*' | ['*'] fragment {'*' fragment} ['*']
fragment ::= char {char}
char ::= nonspace | ' '
nonspace ::= Any XML Char (See http://www.w3.org/TR/REC-xml/) except: '/', ':', '[', ']', '*', ''', '"', '|' or any whitespace character

The pattern is matched against the names (not the paths) of the immediate child properties of this node.

If this node has no accessible matching properties, then an empty iterator is returned.

The same reacquisition semantics apply as with Node.getNode(String) .
Parameters:
  namePattern - a name pattern a PropertyIterator
throws:
  RepositoryException - If an unexpected error occurs.

If the name parameter is null then all referring REFERENCES are returned regardless of name.

Some level 2 implementations may only return properties that have been saved (in a transactional setting this includes both those properties that have been saved but not yet committed, as well as properties that have been committed). Other level 2 implementations may additionally return properties that have been added within the current Session but are not yet saved.

In implementations that support versioning, this method does not return properties that are part of the frozen state of a version in version storage.

If this node has no referring properties with the specified name, an empty iterator is returned.
Parameters:
  name - name of referring REFERENCE properties to bereturned; if null then all referring REFERENCEsare returned A PropertyIterator.
throws:
  RepositoryException - if an error occurs
since:
   JCR 2.0

On nonreferenceable nodes, this method throws an UnsupportedRepositoryOperationException. To avoid throwing an exception to determine whether a node has a UUID, a call to Node.isNodeType(String) isNodeType("mix:referenceable") can be made. Node.getIdentifier() the UUID of this node
throws:
  UnsupportedRepositoryOperationException - If this node nonreferenceable.
throws:
  RepositoryException - If another error occurs.

If this node is not versionable, an UnsupportedRepositoryOperationException is thrown. a VersionHistory object
throws:
  UnsupportedRepositoryOperationException - if this node is not versionable.
throws:
  RepositoryException - If another error occurs.

If the name parameter is null then all referring WEAKREFERENCE are returned regardless of name.

Some level 2 implementations may only return properties that have been saved (in a transactional setting this includes both those properties that have been saved but not yet committed, as well as properties that have been committed). Other level 2 implementations may additionally return properties that have been added within the current Session but are not yet saved.

In implementations that support versioning, this method does not return properties that are part of the frozen state of a version in version storage.

If this node has no referring properties with the specified name, an empty iterator is returned.
Parameters:
  name - name of referring WEAKREFERENCE properties to bereturned; if null then all referring WEAKREFERENCEsare returned A PropertyIterator.
throws:
  RepositoryException - if an error occurs
since:
   JCR 2.0

• versionable (full or simple) and currently checked-out,
• non-versionable and its nearest versionable ancestor is checked-out or
• non-versionable and it has no versionable ancestor.

• versionable (full or simple) and currently checked-in or
• non-versionable and its nearest versionable ancestor is checked-in.

This method respects the effective node type of the node. Note that this may differ from the node type implied by the node's jcr:primaryType property or jcr:mixinTypes property if that property has recently been created or changed and has not yet been saved.
Parameters:
  nodeTypeName - the name of a node type. true If this node is of the specified primary node typeor mixin type, or a subtype thereof. Returns false otherwise.
throws:
  RepositoryException - If an error occurs.

If isDeep is true then the lock applies to this node and all its descendant nodes; if false, the lock applies only to this, the holding node.

If isSessionScoped is true then this lock will expire upon the expiration of the current session (either through an automatic or explicit Session.logout); if false, this lock does not expire until explicitly unlocked or automatically unlocked due to a implementation-specific limitation, such as a timeout.

Returns a Lock object reflecting the state of the new lock.

If the lock is open-scoped the returned lock will include a lock token.

The lock token is also automatically added to the set of lock tokens held by the current Session.

If successful, then the property jcr:lockOwner is created and set to the value of Session.getUserID for the current session and the property jcr:lockIsDeep is set to the value passed in as isDeep. These changes are persisted automatically; there is no need to call save.

Note that it is possible to lock a node even if it is checked-in (the lock-related properties will be changed despite the checked-in status).

If this node is not of mixin node type mix:lockable then an LockException is thrown.

If this node is already locked (either because it holds a lock or a lock above it applies to it), a LockException is thrown.

If isDeep is true and a descendant node of this node already holds a lock, then a LockException is thrown.

If this node does not have a persistent state (has never been saved or otherwise persisted), a LockException is thrown.

If the current session does not have sufficient privileges to place the lock, an AccessDeniedException is thrown.

An UnsupportedRepositoryOperationException is thrown if this implementation does not support locking.

An InvalidItemStateException is thrown if this node has pending unsaved changes.

A RepositoryException is thrown if another error occurs.
Parameters:
  isDeep - if true this lock will apply to this node and all its descendants; iffalse, it applies only to this node.
Parameters:
  isSessionScoped - if true, this lock expires with the current session; if false itexpires when explicitly or automatically unlocked for some other reason. A Lock object containing a lock token.
throws:
  UnsupportedRepositoryOperationException - if this implementation does not support locking.
throws:
  LockException - if this node is not mix:lockable or this node is already locked orisDeep is true and a descendant node of this node already holds a lock.
throws:
  AccessDeniedException - if this session does not have permission to lock this node.
throws:
  InvalidItemStateException - if this node has pending unsaved changes.
throws:
  RepositoryException - if another error occurs.

This method can be thought of as a version-sensitive update.

It recursively tests each versionable node in the subtree of this node against its corresponding node in srcWorkspace with respect to the relation between their respective base versions and either updates the node in question or not, depending on the outcome of the test.

A MergeException is thrown if bestEffort is false and a versionable node is encountered whose corresponding node's base version is on a divergent branch from this node's base version.

If successful, the changes are persisted immediately, there is no need to call save.

This method returns a NodeIterator over all versionable nodes in the subtree that received a merge result of fail. If bestEffort is false, this iterator will be empty (since if merge returns successfully, instead of throwing an exception, it will be because no failures were encountered). If bestEffort is true, this iterator will contain all nodes that received a fail during the course of this merge operation.

If the specified srcWorkspace does not exist, a NoSuchWorkspaceException is thrown.

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 (not necessarily this Node) has pending unsaved changes.

A LockException is thrown if a lock prevents the merge.
Parameters:
  srcWorkspace - the name of the source workspace.
Parameters:
  bestEffort - a boolean iterator over all nodes that received a merge result of "fail" in the courseof this operation.
throws:
  MergeException - if bestEffort is false and a failed mergeresult is encountered.
throws:
  InvalidItemStateException - if this session (not necessarily thisnode) has pending unsaved changes.
throws:
  NoSuchWorkspaceException - if the specified srcWorkspace does not exist.
throws:
  AccessDeniedException - if the current session does not have sufficientrights to perform the operation.
throws:
  LockException - if a lock prevents the merge.
throws:
  RepositoryException - if another error occurs.

This method can be thought of as a version-sensitive update.

If isShallow is true, it tests this versionable node against its corresponding node in srcWorkspace with respect to the relation between their respective base versions and either updates the node in question or not, depending on the outcome of the test.

If isShallow is false, it recursively tests each versionable node in the subtree as mentioned above.

If isShallow is true and this node is not versionable, then this method returns and no changes are made.

A MergeException is thrown if bestEffort is false and a versionable node is encountered whose corresponding node's base version is on a divergent branch from this node's base version.

If successful, the changes are persisted immediately, there is no need to call save.

This method returns a NodeIterator over all versionable nodes in the subtree that received a merge result of fail. If bestEffort is false, this iterator will be empty (since if merge returns successfully, instead of throwing an exception, it will be because no failures were encountered). If bestEffort is true, this iterator will contain all nodes that received a fail during the course of this merge operation.

If the specified srcWorkspace does not exist, a NoSuchWorkspaceException is thrown.

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 (not necessarily this node) has pending unsaved changes.

A LockException is thrown if a lock prevents the merge.
Parameters:
  srcWorkspace - the name of the source workspace.
Parameters:
  bestEffort - a boolean
Parameters:
  isShallow - a boolean iterator over all nodes that received a merge result of "fail" in the courseof this operation.
throws:
  MergeException - if bestEffort is false and a failed mergeresult is encountered.
throws:
  InvalidItemStateException - if this session (not necessarily thisnode) has pending unsaved changes.
throws:
  NoSuchWorkspaceException - if srcWorkspace does not exist.
throws:
  AccessDeniedException - if the current session does not have sufficientrights to perform the operation.
throws:
  LockException - if a lock prevents the merge.
throws:
  RepositoryException - if another error occurs.
since:
   JCR 2.0

To place the node srcChildRelPath at the end of the list, a destChildRelPath of null is used.

Note that (apart from the case where destChildRelPath is null) both of these arguments must be relative paths of depth one, in other words they are the names of the child nodes, possibly suffixed with an index.

If srcChildRelPath and destChildRelPath are the same, then no change is made.

Changes to ordering of child nodes are persisted on save of the parent node. But, if this node does not support child node ordering, then a UnsupportedRepositoryOperationException thrown.

If srcChildRelPath is not the relative path to a child node of this node then an ItemNotFoundException is thrown.

If destChildRelPath is neither the relative path to a child node of this node nor null, then an ItemNotFoundException is also thrown.

A ConstraintViolationException will be thrown either immediately or on save if this operation would violate a node type or implementation-specific constraint. Implementations may differ on when this validation is performed.

A VersionException will be thrown either immediately or on save, if this node is versionable and checked-in or is non-versionable but its nearest versionable ancestor is checked-in. Implementations may differ on when this validation is performed.

A LockException will be thrown either immediately (by this method), or on save, if a lock prevents the re-ordering. Implementations may differ on when this validation is performed.
Parameters:
  srcChildRelPath - the relative path to the child node (that is, name plus possible index)to be moved in the ordering
Parameters:
  destChildRelPath - the the relative path to the child node (that is, name plus possible index)before which the node srcChildRelPath will be placed.
throws:
  UnsupportedRepositoryOperationException - if ordering is not supported.
throws:
  ConstraintViolationException - if an implementation-specific ordering restriction is violatedand this implementation performs this validation immediately instead of waiting until save.
throws:
  ItemNotFoundException - if either parameter is not the relative path of a child node of this node.
throws:
  VersionException - if this node is versionable and checked-in or is non-versionable but itsnearest versionable ancestor is checked-in and this implementation performs this validation immediately insteadof waiting until save..
throws:
  LockException - if a lock prevents the re-ordering and this implementation performs this validationimmediately instead of waiting until save..
throws:
  RepositoryException - if another error occurs.

If this is the last holdID in the property then the hold on this node is lifted.

An UnsupportedRepositoryOperationException is thrown if this node is not of type mix:managedRetention.

A RepositoryException is thrown if another error occurs.
Parameters:
  holdID - a string
throws:
  UnsupportedRepositoryOperationException - if this node is not oftype mix:managedRetention.
throws:
  RepositoryException - if another error occurs.
since:
   JCR 2.0

If this node does not have the specified mixin, a NoSuchNodeTypeException is thrown either immediately or on save. Implementations may differ on when this validation is done.

A ConstraintViolationException will be thrown either immediately or on save if the removal of a mixin is not allowed. Implementations are free to enforce any policy they like with regard to mixin removal and may differ on when this validation is done.

A VersionException is thrown either immediately or on save if this node is versionable and checked-in or is non-versionable but its nearest versionable ancestor is checked-in. Implementations may differ on when this validation is done.

A LockException is thrown either immediately or on save if a lock prevents the removal of the mixin. Implementations may differ on when this validation is done.
Parameters:
  mixinName - the name of the mixin node type to be removed.
throws:
  NoSuchNodeTypeException - if the specified mixinNameis not currently assigned to this node and thisimplementation performs this validation immediately instead of waiting until save.
throws:
  ConstraintViolationException - if the specified mixin node typeis prevented from being removed and thisimplementation performs this validation immediately instead of waiting until save.
throws:
  VersionException - if this node is versionable and checked-in or is non-versionable but itsnearest versionable ancestor is checked-in and thisimplementation performs this validation immediately instead of waiting until save.
throws:
  LockException - if a lock prevents the removal of the mixin and thisimplementation performs this validation immediately instead of waiting until save..
throws:
  RepositoryException - if another error occurs.

Removes the jcr:retentionPolicy property from this node.

A ConstraintViolationException is thrown if this node does not have a retention policy currently assigned.

An UnsupportedRepositoryOperationException is thrown if this node is not of type mix:managedRetention.

A RepositoryException is thrown if another error occurs.
throws:
  ConstraintViolationException - if this node does not have aretention policy currently assigned.
throws:
  UnsupportedRepositoryOperationException - if this node is not oftype mix:managedRetention.
throws:
  RepositoryException - if another error occurs.
since:
   JCR 2.0

All of the exceptions defined for remove() apply to this function. In addition, a RepositoryException is thrown if this node cannot be removed without removing another node in the shared set of this node.

If this node is not shared this method removes only this node.
throws:
  VersionException -
throws:
  LockException -
throws:
  ConstraintViolationException -
throws:
  RepositoryException -
See Also:   Node.removeSharedSet()
See Also:   Item.remove
since:
   JCR 2.0

This removal must be done atomically, i.e., if one of the nodes cannot be removed, the function throws the exception remove() would have thrown in that case, and none of the nodes are removed.

If this node is not shared this method removes only this node.
throws:
  VersionException -
throws:
  LockException -
throws:
  ConstraintViolationException -
throws:
  RepositoryException -
See Also:   Node.removeShare()
See Also:   Item.remove
since:
   JCR 2.0

If this node is not versionable, an UnsupportedRepositoryOperationException is thrown.

If successful, the change is persisted immediately and there is no need to call save.

A VersionException is thrown if no version with the specified versionName exists in this node's version history or if an attempt is made to restore the root version (jcr:rootVersion).

An InvalidItemStateException is thrown if this Session (not necessarily this Node) has pending unsaved changes.

A LockException is thrown if a lock prevents the addition of the mixin.

This method will work regardless of whether this node is checked-in or not.

An identifier collision occurs when a node exists outside the subtree rooted at this node with the same identifier as a node that would be introduced by the restore operation into the subtree at this node. 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 possible; otherwise a RepositoryException is thrown). 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.
Parameters:
  versionName - a Version object
Parameters:
  removeExisting - a boolean flag that governs what happens in case of an identifier collision.
throws:
  UnsupportedRepositoryOperationException - if this node is not versionable.
throws:
  VersionException - if the specified version is not part of this node's version historyor if an attempt is made to restore the root version (jcr:rootVersion).
throws:
  ItemExistsException - if removeExisting is false and an identifier collision occurs.
throws:
  LockException - if a lock prevents the restore.
throws:
  InvalidItemStateException - if this Session (not necessarily this Node) has pending unsaved changes.
throws:
  RepositoryException - If another error occurs.

If this node is not versionable, an UnsupportedRepositoryOperationException is thrown.

If successful, the change is persisted immediately and there is no need to call save.

A VersionException is thrown if the specified version is not part of this node's version history or if an attempt is made to restore the root version (jcr:rootVersion).

An InvalidItemStateException is thrown if this Session (not necessarily this Node) has pending unsaved changes.

A LockException is thrown if a lock prevents the restore.

This method will work regardless of whether this node is checked-in or not.

An identifier collision occurs when a node exists outside the subtree rooted at this node with the same identifier as a node that would be introduced by the restore operation into the subtree at this node. 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 possible; otherwise a RepositoryException is thrown). 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.
Parameters:
  version - a Version object
Parameters:
  removeExisting - a boolean flag that governs what happens in case of an identifier collision.
throws:
  UnsupportedRepositoryOperationException - if this node is not versionable.
throws:
  VersionException - if the specified version is not part of this node's version historyor if an attempt is made to restore the root version (jcr:rootVersion).
throws:
  ItemExistsException - if removeExisting is false and an identifier collision occurs.
throws:
  InvalidItemStateException - if this Session (not necessarily this Node)has pending unsaved changes.
throws:
  LockException - if a lock prevents the restore.
throws:
  RepositoryException - if another error occurs.

A node need not exist at relPath, though the parent of relPath must exist, otherwise a PathNotFoundException is thrown.

If a node does exist at relPath then it must correspond to the version being restored (the version must be a version of that node) and must not be a root version (jcr:rootVersion), otherwise a VersionException is thrown.

If no node exists at relPath then a VersionException is thrown if the parent node of relPath is versionable and checked-in or is non-versionable but its nearest versionable ancestor is checked-in.

If there is a node at relPath then the checked-in status of that node itself and the checked-in status of its parent are irrelevant. The restore will work even if one or both are checked-in.

An identifier collision occurs when a node exists outside the subtree rooted at relPath with the same identifier as a node that would be introduced by the restore operation into the subtree at relPath (Note that in cases where there is no node at relPath, this amounts to saying that an identifier collsion occurs if there exists a node anywhere in this workspace with the same identifier as a node that would be introduced by the restore). 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 possible; otherwise a RepositoryException is thrown). 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.

If the would-be parent of the location relPath is actually a property, or if a node type restriction would be violated, then a ConstraintViolationException is thrown.

If the restore succeeds, the changes made to this node are persisted immediately, there is no need to call save.

An InvalidItemStateException is thrown if this Session (not necessarily this Node) has pending unsaved changes.

An UnsupportedRepositoryOperationException is thrown if versioning is not supported.

A LockException is thrown if a lock prevents the restore.
Parameters:
  version - a version object
Parameters:
  relPath - the path to which the version is to be restored
Parameters:
  removeExisting - overns what happens on identifier collision.
throws:
  PathNotFoundException - if the parent of relPath does not exist.
throws:
  ItemExistsException - if removeExisting is false and an identifier collision occurs
throws:
  ConstraintViolationException - If the would-be parent of the location relPath isactually a property, or if a node type restriction would be violated
throws:
  VersionException - if the parent node of relPath is versionable and checked-in or isnon-versionable but its nearest versionable ancestor is checked-in or if a node exists at relPath that is notthe node corresponding to the specified version or if an attempt is made to restore the root version(jcr:rootVersion).
throws:
  UnsupportedRepositoryOperationException - if versioning is not supported.
throws:
  LockException - if a lock prevents the restore.
throws:
  InvalidItemStateException - if this Session (not necessarily this Node) has pending unsaved changes.
throws:
  RepositoryException - if another error occurs

A VersionException is thrown if the specified versionLabel does not exist in this node's version history.

An InvalidItemStateException is thrown if this Session (not necessarily this Node) has pending unsaved changes.

A LockException is thrown if a lock prevents the restore.

This method will work regardless of whether this node is checked-in or not.

An identifier collision occurs when a node exists outside the subtree rooted at this node with the same identifier as a node that would be introduced by the restoreByLabel operation into the subtree at this node. 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 possible; otherwise a RepositoryException is thrown). 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.
Parameters:
  versionLabel - a String
Parameters:
  removeExisting - a boolean flag that governs what happens in case of an identifier collision.
throws:
  UnsupportedRepositoryOperationException - if this node is not verisonable.
throws:
  VersionException - if the specified versionLabeldoes not exist in this node's version history.
throws:
  ItemExistsException - if removeExisting is false and an identifier collision occurs.
throws:
  LockException - if a lock prevents the restore.
throws:
  InvalidItemStateException - if this Session (not necessarily this Node) has pending unsaved changes.
throws:
  RepositoryException - If another error occurs.

The supplied holdID is added to the jcr:hold multi-value property and the corresponding jcr:isDeep value is set accordingly. The corresponding jcr:isDeep value is the one with the same index as the holdID value.

The format and interpretation of the holdID is not specified. It is expected to be an identifier associated with the application placing the hold.

An UnsupportedRepositoryOperationException is thrown if this node is not of type mix:managedRetention.

A RepositoryException is thrown if another error occurs.
Parameters:
  holdID - a string
Parameters:
  isDeep - a boolean
throws:
  UnsupportedRepositoryOperationException - if this node is not oftype mix:managedRetention.
throws:
  RepositoryException - if another error occurs.
since:
   JCR 2.0

If the presence of an existing property or child node would cause an incompatibility with the new node type a ConstraintViolationException is thrown either immediately or on save.

If the new node type would cause this node to be incompatible with the node type of its parent then a ConstraintViolationException is thrown either immediately or on save.

A ConstraintViolationException is also thrown either immediately or on save if a conflict with an already assigned mixin occurs.

A ConstraintViolationException may also be thrown either immediately or on save if the attempted change violates implementation-specific node type transition rules. A repository that disallows all primary node type changes would simple throw this exception in all cases.

If the specified node type is not recognized a NoSuchNodeTypeException is thrown either immediately or on save.

A VersionException is thrown either immediately or on save if this node is versionable and checked-in, or is non-versionable but its nearest versionable ancestor is checked-in.

A LockException is thrown either immediately or on save if a lock prevents the change of node type.

A RepositoryException will be thrown if another error occurs.
Parameters:
  nodeTypeName - the name of the new node type.
throws:
  ConstraintViolationException - If the specified primary node typeis prevented from being assigned.
throws:
  NoSuchNodeTypeException - If the specified nodeTypeNameis not recognized and this implementation performs this validationimmediately instead of waiting until save.
throws:
  VersionException - if this node is versionable and checked-in or isnon-versionable but its nearest versionable ancestor is checked-in and thisimplementation performs this validation immediately instead of waiting untilsave.
throws:
  LockException - if a lock prevents the change of the primary node typeand this implementation performs this validation immediately instead ofwaiting until save.
throws:
  RepositoryException - if another error occurs.
since:
   JCR 2.0

If, based on the name and value passed, there is more than one property definition that applies, the repository chooses one definition according to some implementation-specific criteria. Once property with name P has been created, the behavior of a subsequent setProperty(P,V) may differ across implementations. Some repositories may allow P to be dynamically re-bound to a different property definition (based for example, on the new value being of a different type than the original value) while other repositories may not allow such dynamic re-binding.

If the property type of the supplied Value object is different from that required, then a best-effort conversion is attempted. If the conversion fails, a ValueFormatException is thrown. If another error occurs, a RepositoryException is thrown.

If the node type of this node does not indicate a specific property type, then the property type of the supplied Value object is used and if the property already exists it assumes both the new value and new property type.

If the property is multi-valued, a ValueFormatException is thrown.

Passing a null as the second parameter removes the property. It is equivalent to calling remove on the Property object itself. For example, N.setProperty("P", (Value)null) would remove property called "P" of the node in N.

To save the addition or removal of a property, a save call must be performed that includes the parent of the property in its scope, that is, a save on either the session, this node, or an ancestor of this node. To save a change to an existing property, a save call that includes that property in its scope is required. This means that in addition to the above-mentioned save options, a save on the changed property itself will also work.

A ConstraintViolationException will be thrown either immediately or on save if the change would violate a node type or implementation-specific constraint. Implementations may differ on when this validation is performed.

A VersionException will be thrown either immediately or on save if this node is versionable and checked-in or is non-versionable but its nearest versionable ancestor is checked-in. Implementations may differ on when this validation is performed.

A LockException will be thrown either immediately or on save if a lock prevents the setting of the property. Implementations may differ on when this validation is performed.
Parameters:
  name - The name of a property of this node
Parameters:
  value - The value to be assigned The updated Property object
throws:
  ValueFormatException - if value cannot be converted to the type of the specifiedproperty or if the property already exists and is multi-valued.
throws:
  VersionException - if this node is versionable and checked-in or is non-versionable but itsnearest versionable ancestor is checked-in and thisimplementation performs this validation immediately instead of waiting until save.
throws:
  LockException - if a lock prevents the setting of the property and thisimplementation performs this validation immediately instead of waiting until save.
throws:
  ConstraintViolationException - if the change would violate a node-type or other constraintand this implementation performs this validation immediately instead of waiting until save.
throws:
  RepositoryException - if another error occurs.

The type of the new property is determined by the type parameter specified.

If the property type of the supplied Value object is different from that required, then a best-effort conversion is attempted. If the conversion fails, a ValueFormatException is thrown.

If the property is not single-valued then a ValueFormatException is also thrown.

If the property already exists it assumes both the new value and the new property type.

Passing a null as the second parameter removes the property. It is equivalent to calling remove on the Property object itself. For example, N.setProperty("P", (Value)null, type) would remove property called "P" of the node in N.

To persist the addition or removal of a property, save must be called on the Session, this Node, or an ancestor of this Node.

To save the addition or removal of a property, a save call must be performed that includes the parent of the property in its scope, that is, a save on either the session, this node, or an ancestor of this node. To save a change to an existing property, a save call that includes that property in its scope is required. This means that in addition to the above-mentioned save options, a save on the changed property itself will also work.

A ConstraintViolationException will be thrown either immediately or on save if the change would violate a node type or implementation-specific constraint. Implementations may differ on when this validation is performed.

A VersionException will be thrown either immediately or on save if this node is versionable and checked-in or is non-versionable but its nearest versionable ancestor is checked-in. Implementations may differ on when this validation is performed.

A LockException will be thrown either immediately or on save if a lock prevents the setting of the property. Implementations may differ on when this validation is performed.
Parameters:
  name - the name of the property to be set.
Parameters:
  value - a Value object.
Parameters:
  type - the type of the property. the Property object set, or nullif this method was used to remove a property (by setting its value to null).
throws:
  ValueFormatException - if value cannot be converted to the specified typeor if the property already exists and is multi-valued.
throws:
  VersionException - if this node is versionable and checked-in or is non-versionable but itsnearest versionable ancestor is checked-in and thisimplementation performs this validation immediately instead of waiting until save.
throws:
  LockException - if a lock prevents the setting of the property and thisimplementation performs this validation immediately instead of waiting until save.
throws:
  ConstraintViolationException - if the change would violate a node-type or other constraintand this implementation performs this validation immediately instead of waiting until save.
throws:
  RepositoryException - if another error occurs.

The property type of the property will be that specified by the node type of this node. If the property type of the supplied Value objects is different from that required, then a best-effort conversion is attempted. If the conversion fails, a ValueFormatException is thrown.

All Value objects in the array must be of the same type, otherwise a ValueFormatException is thrown. If the property is not multi-valued then a ValueFormatException is also thrown. If another error occurs, a RepositoryException is thrown.

If the node type of this node does not indicate a specific property type, then the property type of the supplied Value objects is used and if the property already exists it assumes both the new values and the new property type.

Passing a null as the second parameter removes the property. It is equivalent to calling remove on the Property object itself. For example, N.setProperty("P", (Value[])null) would remove property called "P" of the node in N.

Note that this is different from passing an array that contains null elements. In such a case, the array is compacted by removing the nulls. The resulting set of values never contains nulls. However, the set may be empty: N.setProperty("P", new Value[]{null}) would set the property to the empty set of values.

To save the addition or removal of a property, a save call must be performed that includes the parent of the property in its scope, that is, a save on either the session, this node, or an ancestor of this node. To save a change to an existing property, a save call that includes that property in its scope is required. This means that in addition to the above-mentioned save options, a save on the changed property itself will also work.

A ConstraintViolationException will be thrown either immediately or on save if the change would violate a node type or implementation-specific constraint. Implementations may differ on when this validation is performed.

A VersionException will be thrown either immediately or on save if this node is versionable and checked-in or is non-versionable but its nearest versionable ancestor is checked-in. Implementations may differ on when this validation is performed.

A LockException will be thrown either immediately or on save if a lock prevents the setting of the property. Implementations may differ on when this validation is performed.
Parameters:
  name - the name of the property to be set.
Parameters:
  values - an array of Value objects. the updated Property object.
throws:
  ValueFormatException - if value cannot be converted to the type of the specified propertyor if the property already exists and is not multi-valued.
throws:
  VersionException - if this node is versionable and checked-in or is non-versionable but itsnearest versionable ancestor is checked-in and thisimplementation performs this validation immediately instead of waiting until save.
throws:
  LockException - if a lock prevents the setting of the property and thisimplementation performs this validation immediately instead of waiting until save.
throws:
  ConstraintViolationException - if the change would violate a node-type or other constraintand this implementation performs this validation immediately instead of waiting until save.
throws:
  RepositoryException - if another error occurs.

If the property type of the supplied Value objects is different from that specified, then a best-effort conversion is attempted. If the conversion fails, a ValueFormatException is thrown.

If the property already exists it assumes both the new values and the new property type.

All Value objects in the array must be of the same type, otherwise a ValueFormatException is thrown. If the property is not multi-valued then a ValueFormatException is also thrown. If another error occurs, a RepositoryException is thrown.

Passing a null as the second parameter removes the property. It is equivalent to calling remove on the Property object itself. For example, N.setProperty("P", (Value[])null, type) would remove property called "P" of the node in N.

Note that this is different from passing an array that contains null elements. In such a case, the array is compacted by removing the nulls. The resulting set of values never contains nulls. However, the set may be empty: N.setProperty("P", new Value[]{null}, type) would set the property to the empty set of values.

To save the addition or removal of a property, a save call must be performed that includes the parent of the property in its scope, that is, a save on either the session, this node, or an ancestor of this node. To save a change to an existing property, a save call that includes that property in its scope is required. This means that in addition to the above-mentioned save options, a save on the changed property itself will also work.

A ConstraintViolationException will be thrown either immediately or on save if the change would violate a node type or implementation-specific constraint. Implementations may differ on when this validation is performed.

A VersionException will be thrown either immediately or on save if this node is versionable and checked-in or is non-versionable but its nearest versionable ancestor is checked-in. Implementations may differ on when this validation is performed.

A LockException will be thrown either immediately or on save if a lock prevents the setting of the property. Implementations may differ on when this validation is performed.
Parameters:
  name - the name of the property to be set.
Parameters:
  values - an array of Value objects.
Parameters:
  type - the type of the property. the updated Property object.
throws:
  ValueFormatException - if value cannot be converted to the specified typeor if the property already exists and is not multi-valued.
throws:
  VersionException - if this node is versionable and checked-in or is non-versionable but itsnearest versionable ancestor is checked-in and thisimplementation performs this validation immediately instead of waiting until save.
throws:
  LockException - if a lock prevents the setting of the property and thisimplementation performs this validation immediately instead of waiting until save.
throws:
  ConstraintViolationException - if the change would violate a node-type or other constraintand this implementation performs this validation immediately instead of waiting until save.
throws:
  RepositoryException - if another error occurs.

If the node type of this node does not specify a particular property type for the property being set then PropertyType.STRING is used and, if the property already exists, it assumes both the new value and type PropertyType.STRING.

Passing a null as the second parameter removes the property. It is equivalent to calling remove on the Property object itself. For example, N.setProperty("P", (String)null) would remove property called "P" of the node in N.

To save the addition or removal of a property, a save call must be performed that includes the parent of the property in its scope, that is, a save on either the session, this node, or an ancestor of this node. To save a change to an existing property, a save call that includes that property in its scope is required. This means that in addition to the above-mentioned save options, a save on the changed property itself will also work.

A ConstraintViolationException will be thrown either immediately or on save if the change would violate a node type or implementation-specific constraint. Implementations may differ on when this validation is performed.

A VersionException will be thrown either immediately or on save if this node is versionable and checked-in or is non-versionable but its nearest versionable ancestor is checked-in. Implementations may differ on when this validation is performed.

A LockException will be thrown either immediately or on save if a lock prevents the setting of the property. Implementations may differ on when this validation is performed.
Parameters:
  name - The name of a property of this node
Parameters:
  value - The value to assigned The updated Property object
throws:
  ValueFormatException - if value cannot be converted to the type of the specified propertyor if the property already exists and is multi-valued.
throws:
  VersionException - if this node is versionable and checked-in or is non-versionable but itsnearest versionable ancestor is checked-in and thisimplementation performs this validation immediately instead of waiting until save.
throws:
  LockException - if a lock prevents the setting of the property and thisimplementation performs this validation immediately instead of waiting until save.
throws:
  ConstraintViolationException - if the change would violate a node-type or other constraintand this implementation performs this validation immediately instead of waiting until save.
throws:
  RepositoryException - If another error occurs.

The type of the property is determined by the type parameter specified.

If the property type specified is not PropertyType.STRING, then a best-effort conversion is attempted. If the conversion fails, a ValueFormatException is thrown.

If the property is not single-valued then a ValueFormatException is also thrown.

If the property already exists it assumes both the new value and the new property type.

Passing a null as the second parameter removes the property. It is equivalent to calling remove on the Property object itself. For example, N.setProperty("P", (Value)null, type) would remove property called "P" of the node in N.

To save the addition or removal of a property, a save call must be performed that includes the parent of the property in its scope, that is, a save on either the session, this node, or an ancestor of this node. To save a change to an existing property, a save call that includes that property in its scope is required. This means that in addition to the above-mentioned save options, a save on the changed property itself will also work.

A ConstraintViolationException will be thrown either immediately or on save if the change would violate a node type or implementation-specific constraint. Implementations may differ on when this validation is performed.

A VersionException will be thrown either immediately or on save if this node is versionable and checked-in or is non-versionable but its nearest versionable ancestor is checked-in. Implementations may differ on when this validation is performed.

A LockException will be thrown either immediately or on save if a lock prevents the setting of the property. Implementations may differ on when this validation is performed.
Parameters:
  name - the name of the property to be set.
Parameters:
  value - a String object.
Parameters:
  type - the type of the property. the Property object set, or nullif this method was used to remove a property (by setting its value to null).
throws:
  ValueFormatException - if value cannot be converted to the specified typeor if the property already exists and is multi-valued.
throws:
  VersionException - if this node is versionable and checked-in or is non-versionable but itsnearest versionable ancestor is checked-in and thisimplementation performs this validation immediately instead of waiting until save.
throws:
  LockException - if a lock prevents the setting of the property and thisimplementation performs this validation immediately instead of waiting until save.
throws:
  ConstraintViolationException - if the change would violate a node-type or other constraintand this implementation performs this validation immediately instead of waiting until save.
throws:
  RepositoryException - if another error occurs.

If the node type of this node does not specify a particular property type for the property being set then PropertyType.BINARY is used and, if the property already exists, it assumes both the new value and type PropertyType.BINARY.

Passing a null as the second parameter removes the property. It is equivalent to calling remove on the Property object itself. For example, N.setProperty("P", (InputStream)null) would remove property called "P" of the node in N.

To save the addition or removal of a property, a save call must be performed that includes the parent of the property in its scope, that is, a save on either the session, this node, or an ancestor of this node. To save a change to an existing property, a save call that includes that property in its scope is required. This means that in addition to the above-mentioned save options, a save on the changed property itself will also work.

The passed stream is closed before this method returns either normally or because of an exception.

A ConstraintViolationException will be thrown either immediately or on save if the change would violate a node type or implementation-specific constraint. Implementations may differ on when this validation is performed.

A VersionException will be thrown either immediately or on save if this node is versionable and checked-in or is non-versionable but its nearest versionable ancestor is checked-in. Implementations may differ on when this validation is performed.

A LockException will be thrown either immediately or on save if a lock prevents the setting of the property. Implementations may differ on when this validation is performed. Node.setProperty(String,Binary)
Parameters:
  name - The name of a property of this node
Parameters:
  value - The value to assigned The updated Property object
throws:
  ValueFormatException - if value cannot be converted to the type of the specified propertyor if the property already exists and is multi-valued.
throws:
  VersionException - if this node is versionable and checked-in or is non-versionable but itsnearest versionable ancestor is checked-in and thisimplementation performs this validation immediately instead of waiting until save.
throws:
  LockException - if a lock prevents the setting of the property and thisimplementation performs this validation immediately instead of waiting until save.
throws:
  ConstraintViolationException - if the change would violate a node-type or other constraintand this implementation performs this validation immediately instead of waiting until save.
throws:
  RepositoryException - If another error occurs.

If the node type of this node does not specify a particular property type for the property being set then PropertyType.BINARY is used and, if the property already exists, it assumes both the new value and type PropertyType.BINARY.

Passing a null as the second parameter removes the property. It is equivalent to calling remove on the Property object itself. For example, N.setProperty("P", (Binary)null) would remove property called "P" of the node in N.

To save the addition or removal of a property, a save call must be performed that includes the parent of the property in its scope, that is, a save on either the session, this node, or an ancestor of this node. To save a change to an existing property, a save call that includes that property in its scope is required. This means that in addition to the above-mentioned save options, a save on the changed property itself will also work.

A ConstraintViolationException will be thrown either immediately or on save if the change would violate a node type or implementation-specific constraint. Implementations may differ on when this validation is performed.

A VersionException will be thrown either immediately or on save if this node is versionable and checked-in or is non-versionable but its nearest versionable ancestor is checked-in. Implementations may differ on when this validation is performed.

A LockException will be thrown either immediately or on save if a lock prevents the setting of the property. Implementations may differ on when this validation is performed.
Parameters:
  name - The name of a property of this node
Parameters:
  value - The value to assigned The updated Property object
throws:
  ValueFormatException - if value cannot be converted to the type of the specified propertyor if the property already exists and is multi-valued.
throws:
  VersionException - if this node is versionable and checked-in or is non-versionable but itsnearest versionable ancestor is checked-in and thisimplementation performs this validation immediately instead of waiting until save.
throws:
  LockException - if a lock prevents the setting of the property and thisimplementation performs this validation immediately instead of waiting until save.
throws:
  ConstraintViolationException - if the change would violate a node-type or other constraintand this implementation performs this validation immediately instead of waiting until save.
throws:
  RepositoryException - If another error occurs.
since:
   JCR 2.0

If the node type of this node does not specify a particular property type for the property being set then PropertyType.BOOLEAN is used and, if the property already exists, it assumes both the new value and type PropertyType.BOOLEAN.

To save the addition or removal of a property, a save call must be performed that includes the parent of the property in its scope, that is, a save on either the session, this node, or an ancestor of this node. To save a change to an existing property, a save call that includes that property in its scope is required. This means that in addition to the above-mentioned save options, a save on the changed property itself will also work.

A ConstraintViolationException will be thrown either immediately or on save if the change would violate a node type or implementation-specific constraint. Implementations may differ on when this validation is performed.

A VersionException will be thrown either immediately or on save if this node is versionable and checked-in or is non-versionable but its nearest versionable ancestor is checked-in. Implementations may differ on when this validation is performed.

A LockException will be thrown either immediately or on save if a lock prevents the setting of the property. Implementations may differ on when this validation is performed.
Parameters:
  name - The name of a property of this node
Parameters:
  value - The value to assigned The updated Property object
throws:
  ValueFormatException - if value cannot be converted to the type of the specified propertyor if the property already exists and is multi-valued.
throws:
  VersionException - if this node is versionable and checked-in or is non-versionable but itsnearest versionable ancestor is checked-in and thisimplementation performs this validation immediately instead of waiting until save.
throws:
  LockException - if a lock prevents the setting of the property and thisimplementation performs this validation immediately instead of waiting until save.
throws:
  ConstraintViolationException - if the change would violate a node-type or other constraintand this implementation performs this validation immediately instead of waiting until save.
throws:
  RepositoryException - If another error occurs.

If the node type of this node does not specify a particular property type for the property being set then PropertyType.DOUBLE is used and, if the property already exists, it assumes both the new value and type PropertyType.DOUBLE.

To save the addition or removal of a property, a save call must be performed that includes the parent of the property in its scope, that is, a save on either the session, this node, or an ancestor of this node. To save a change to an existing property, a save call that includes that property in its scope is required. This means that in addition to the above-mentioned save options, a save on the changed property itself will also work.

A ConstraintViolationException will be thrown either immediately or on save if the change would violate a node type or implementation-specific constraint. Implementations may differ on when this validation is performed.

A VersionException will be thrown either immediately or on save if this node is versionable and checked-in or is non-versionable but its nearest versionable ancestor is checked-in. Implementations may differ on when this validation is performed.

A LockException will be thrown either immediately or on save if a lock prevents the setting of the property. Implementations may differ on when this validation is performed.
Parameters:
  name - The name of a property of this node
Parameters:
  value - The value to assigned The updated Property object
throws:
  ValueFormatException - if value cannot be converted to the type of the specified propertyor if the property already exists and is multi-valued.
throws:
  VersionException - if this node is versionable and checked-in or is non-versionable but itsnearest versionable ancestor is checked-in and thisimplementation performs this validation immediately instead of waiting until save.
throws:
  LockException - if a lock prevents the setting of the property and thisimplementation performs this validation immediately instead of waiting until save.
throws:
  ConstraintViolationException - if the change would violate a node-type or other constraintand this implementation performs this validation immediately instead of waiting until save.
throws:
  RepositoryException - If another error occurs.

If the node type of this node does not specify a particular property type for the property being set then PropertyType.DECIMAL is used and, if the property already exists, it assumes both the new value and type PropertyType.DECIMAL.

To save the addition or removal of a property, a save call must be performed that includes the parent of the property in its scope, that is, a save on either the session, this node, or an ancestor of this node. To save a change to an existing property, a save call that includes that property in its scope is required. This means that in addition to the above-mentioned save options, a save on the changed property itself will also work.

A ConstraintViolationException will be thrown either immediately or on save if the change would violate a node type or implementation-specific constraint. Implementations may differ on when this validation is performed.

A VersionException will be thrown either immediately or on save if this node is versionable and checked-in or is non-versionable but its nearest versionable ancestor is checked-in. Implementations may differ on when this validation is performed.

A LockException will be thrown either immediately or on save if a lock prevents the setting of the property. Implementations may differ on when this validation is performed.
Parameters:
  name - The name of a property of this node
Parameters:
  value - The value to assigned The updated Property object
throws:
  ValueFormatException - if value cannot be converted to the type of the specified propertyor if the property already exists and is multi-valued.
throws:
  VersionException - if this node is versionable and checked-in or is non-versionable but itsnearest versionable ancestor is checked-in and thisimplementation performs this validation immediately instead of waiting until save.
throws:
  LockException - if a lock prevents the setting of the property and thisimplementation performs this validation immediately instead of waiting until save.
throws:
  ConstraintViolationException - if the change would violate a node-type or other constraintand this implementation performs this validation immediately instead of waiting until save.
throws:
  RepositoryException - If another error occurs.
since:
   JCR 2.0

If the node type of this node does not specify a particular property type for the property being set then PropertyType.LONG is used and, if the property already exists, it assumes both the new value and type PropertyType.LONG.

To save the addition or removal of a property, a save call must be performed that includes the parent of the property in its scope, that is, a save on either the session, this node, or an ancestor of this node. To save a change to an existing property, a save call that includes that property in its scope is required. This means that in addition to the above-mentioned save options, a save on the changed property itself will also work.

A ConstraintViolationException will be thrown either immediately or on save if the change would violate a node type or implementation-specific constraint. Implementations may differ on when this validation is performed.

A VersionException will be thrown either immediately or on save if this node is versionable and checked-in or is non-versionable but its nearest versionable ancestor is checked-in. Implementations may differ on when this validation is performed.

A LockException will be thrown either immediately or on save if a lock prevents the setting of the property. Implementations may differ on when this validation is performed.
Parameters:
  name - The name of a property of this node
Parameters:
  value - The value to assigned The updated Property object
throws:
  ValueFormatException - if value cannot be converted to the type of the specified propertyor if the property already exists and is multi-valued.
throws:
  VersionException - if this node is versionable and checked-in or is non-versionable but itsnearest versionable ancestor is checked-in and thisimplementation performs this validation immediately instead of waiting until save.
throws:
  LockException - if a lock prevents the setting of the property and thisimplementation performs this validation immediately instead of waiting until save.
throws:
  ConstraintViolationException - if the change would violate a node-type or other constraintand this implementation performs this validation immediately instead of waiting until save.
throws:
  RepositoryException - If another error occurs.

If the node type of this node does not specify a particular property type for the property being set then PropertyType.DATE is used and, if the property already exists, it assumes both the new value and type PropertyType.DATE.

Passing a null as the second parameter removes the property. It is equivalent to calling remove on the Property object itself. For example, N.setProperty("P", (Calendar)null) would remove property called "P" of the node in N.

To save the addition or removal of a property, a save call must be performed that includes the parent of the property in its scope, that is, a save on either the session, this node, or an ancestor of this node. To save a change to an existing property, a save call that includes that property in its scope is required. This means that in addition to the above-mentioned save options, a save on the changed property itself will also work.

A ConstraintViolationException will be thrown either immediately or on save if the change would violate a node type or implementation-specific constraint. Implementations may differ on when this validation is performed.

A VersionException will be thrown either immediately or on save if this node is versionable and checked-in or is non-versionable but its nearest versionable ancestor is checked-in. Implementations may differ on when this validation is performed.

A LockException will be thrown either immediately or on save if a lock prevents the setting of the property. Implementations may differ on when this validation is performed.
Parameters:
  name - The name of a property of this node
Parameters:
  value - The value to assigned The updated Property object
throws:
  ValueFormatException - if value cannot be converted to the type of the specified propertyor if the property already exists and is multi-valued.
throws:
  VersionException - if this node is versionable and checked-in or is non-versionable but itsnearest versionable ancestor is checked-in and thisimplementation performs this validation immediately instead of waiting until save.
throws:
  LockException - if a lock prevents the setting of the property and thisimplementation performs this validation immediately instead of waiting until save.
throws:
  ConstraintViolationException - if the change would violate a node-type or other constraintand this implementation performs this validation immediately instead of waiting until save.
throws:
  RepositoryException - If another error occurs.

If the node type of this node does not specify a particular property type for the property being set then PropertyType.REFERENCE is used and, if the property already exists, it assumes both the new value and type PropertyType.REFERENCE.

Passing a null as the second parameter removes the property. It is equivalent to calling remove on the Property object itself. For example, N.setProperty("P", (Node)null) would remove property called "P" of the node in N.

To save the addition or removal of a property, a save call must be performed that includes the parent of the property in its scope, that is, a save on either the session, this node, or an ancestor of this node. To save a change to an existing property, a save call that includes that property in its scope is required. This means that in addition to the above-mentioned save options, a save on the changed property itself will also work.

A ConstraintViolationException will be thrown either immediately or on save if the change would violate a node type or implementation-specific constraint. Implementations may differ on when this validation is performed.

A VersionException will be thrown either immediately or on save if this node is versionable and checked-in or is non-versionable but its nearest versionable ancestor is checked-in. Implementations may differ on when this validation is performed.

A LockException will be thrown either immediately or on save if a lock prevents the setting of the property. Implementations may differ on when this validation is performed.
Parameters:
  name - The name of a property of this node
Parameters:
  value - The value to assigned The updated Property object
throws:
  ValueFormatException - if value cannot be converted to the type of the specified propertyor if the property already exists and is multi-valued.
throws:
  VersionException - if this node is versionable and checked-in or is non-versionable but itsnearest versionable ancestor is checked-in and thisimplementation performs this validation immediately instead of waiting until save.
throws:
  LockException - if a lock prevents the setting of the property and thisimplementation performs this validation immediately instead of waiting until save.
throws:
  ConstraintViolationException - if the change would violate a node-type or other constraintand this implementation performs this validation immediately instead of waiting until save.
throws:
  RepositoryException - If another error occurs.

The jcr:retentionPolicy property of this node is set to refer to the policy node.

A ConstraintViolationException is thrown if the specified node is not a valid retention policy node.

An UnsupportedRepositoryOperationException is thrown if this node is not of type mix:managedRetention.

A RepositoryException is thrown if another error occurs.
Parameters:
  policy - a policy node
throws:
  ConstraintViolationException - if the specified node is not a validretention policy node.
throws:
  UnsupportedRepositoryOperationException - if this node is not oftype mix:managedRetention.
throws:
  RepositoryException - if another error occurs.
since:
   JCR 2.0

If this node does not currently hold a lock or holds a lock for which this Session is not the owner, then a LockException is thrown. Note however that the system may give permission to a non-owning session to unlock a lock. Typically such "lock-superuser" capability is intended to facilitate administrational clean-up of orphaned open-scoped locks.

Note that it is possible to unlock a node even if it is checked-in (the lock-related properties will be changed despite the checked-in status).

If the current session does not have sufficient privileges to remove the lock, an AccessDeniedException is thrown.

An InvalidItemStateException is thrown if this node has pending unsaved changes.

An UnsupportedRepositoryOperationException is thrown if this implementation does not support locking.

A RepositoryException is thrown if another error occurs.
throws:
  UnsupportedRepositoryOperationException - if this implementation does not support locking.
throws:
  LockException - if this node does not currently hold a lock or holds a lock for which this Session does not have the correct lock token
throws:
  AccessDeniedException - if the current session does not have permission to unlock this node.
throws:
  InvalidItemStateException - if this node has pending unsaved changes.
throws:
  RepositoryException - if another error occurs.

If this node does not have a corresponding node in the workspace srcWorkspace, then the update method has no effect.

If the update succeeds the changes made are persisted immediately, there is no need to call save.

Note that update does not respect the checked-in status of nodes. An update may change a node even if it is currently checked-in (This fact is only relevant in an implementation that supports versioning).

If the specified srcWorkspace does not exist, a NoSuchWorkspaceException is thrown.

If the current session does not have sufficient rights to perform the operation, then an AccessDeniedException is thrown.

An InvalidItemStateException is thrown if this Session (not necessarily this Node) has pending unsaved changes.

Throws a LockException if a lock prevents the update.

A RepositoryException is thrown if another error occurs.
Parameters:
  srcWorkspace - the name of the source workspace.
throws:
  NoSuchWorkspaceException - If srcWorkspace does not exist.
throws:
  InvalidItemStateException - if this Session (not necessarily this Node) has pending unsaved changes.
throws:
  AccessDeniedException - If the current session does not have sufficient rights to perform the operation.
throws:
  LockException - if a lock prevents the update.
throws:
  RepositoryException - If another error occurs.