* The destAbsPath provided must not * have an index on its final element. If it does then a RepositoryException * is thrown. Strictly speaking, the destAbsPath parameter is actually an absolute path * to the parent node of the new location, appended with the new name desired for the * copied node. It does not specify a position within the child node * ordering. If ordering is supported by the node type of * the parent node of the new location, then the new copy of the node is appended to the end of the * child node list. *

* This method cannot be used to copy just an individual property by itself. * It copies an entire node and its subtree (including, of course, any properties contained therein). *

* A NoSuchWorkspaceException is thrown if srcWorkspace does not * exist or if the current Session does not have permission to access it. *

* A ConstraintViolationException is thrown if the operation would violate a node-type * or other implementation-specific constraint. *

* A VersionException is thrown if the parent node of destAbsPath is * versionable and checked-in, or is non-versionable but its nearest versionable ancestor is * checked-in. *

* An AccessDeniedException is thrown if the current session (i.e. the session that * was used to acquire this Workspace object) does not have sufficient access rights * to complete the operation. *

* A PathNotFoundException is thrown if the node at srcAbsPath or the * parent of the new node at destAbsPath does not exist. *

* An ItemExistException is thrown if a property already exists at * destAbsPath or a node already exist there, and same name * siblings are not allowed. *

* A LockException is thrown if a lock prevents the copy. * * @param srcWorkspace the name of the worksapce from which the copy is to be made. * @param srcAbsPath the path of the node to be copied. * @param destAbsPath the location to which the node at srcAbsPath * is to be copied in this workspace. * @throws NoSuchWorkspaceException if srcWorkspace does not * exist or if the current Session does not have permission to access it. * @throws ConstraintViolationException if the operation would violate a * node-type or other implementation-specific constraint * @throws VersionException if the parent node of destAbsPath is * versionable and checked-in, or is non-versionable but its nearest versionable ancestor is * checked-in. * @throws AccessDeniedException if the current session does have permission to access * srcWorkspace but otherwise does not have sufficient access rights to * complete the operation. * @throws PathNotFoundException if the node at srcAbsPath or * the parent of the new node at destAbsPath does not exist. * @throws ItemExistsException if a property already exists at * destAbsPath or a node already exist there, and same name * siblings are not allowed. * @throws LockException if a lock prevents the copy. * @throws RepositoryException if the last element of destAbsPath * has an index or if another error occurs. */ public function copy( $srcWorkspace, $srcAbsPath, $destAbsPath ); /** * Clones the subtree at the node srcAbsPath in srcWorkspace to the new location at * destAbsPath in this workspace. This method does not assign new UUIDs to * the new nodes but preserves the UUIDs (if any) of their respective source nodes. *

* If removeExisting is true and an existing node in this workspace * (the destination workspace) has the same UUID as a node being cloned from * srcWorkspace, then the incoming node takes precedence, and the * existing node (and its subtree) is removed. If removeExisting * is false then a UUID collision causes this method to throw a * ItemExistsException and no changes are made. *

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

* The destAbsPath provided must not * have an index on its final element. If it does then a RepositoryException * is thrown. Strictly speaking, the destAbsPath parameter is actually an absolute path * to the parent node of the new location, appended with the new name desired for the * cloned node. It does not specify a position within the child node * ordering. If ordering is supported by the node type of the parent node of the new * location, then the new clone of the node is appended to the end of the child node list. *

* This method cannot be used to clone just an individual property by itself. It clones an * entire node and its subtree (including, of course, any properties contained therein). *

* A NoSuchWorkspaceException is thrown if srcWorkspace does not * exist or if the current Session does not have permission to access it. *

* A ConstraintViolationException is thrown if the operation would violate a node-type * or other implementation-specific constraint. *

* A VersionException is thrown if the parent node of destAbsPath is * versionable and checked-in, or is non-versionable but its nearest versionable ancestor is * checked-in. This exception will also be thrown if removeExisting is true, * and a UUID conflict occurs that would require the moving and/or altering of a node that is checked-in. *

* An AccessDeniedException is thrown if the current session (i.e. the session that * was used to acquire this Workspace object) does not have sufficient access rights * to complete the operation. *

* A PathNotFoundException is thrown if the node at srcAbsPath or the * parent of the new node at destAbsPath does not exist. *

* An ItemExistsException is thrown if a node or property already exists at * destAbsPath *

* An ItemExistException is thrown if a property already exists at * destAbsPath or a node already exist there, and same name * siblings are not allowed or if removeExisting is false and a * UUID conflict occurs. *

* A LockException is thrown if a lock prevents the clone. * * @param srcWorkspace The name of the workspace from which the node is to be copied. * @param srcAbsPath the path of the node to be copied in srcWorkspace. * @param destAbsPath the location to which the node at srcAbsPath * is to be copied in this workspace. * @param removeExisting if false then this method throws an * ItemExistsException on UUID conflict with an incoming node. * If true then a UUID conflict is resolved by removing the existing node * from its location in this workspace and cloning (copying in) the one from * srcWorkspace. * * @throws NoSuchWorkspaceException if destWorkspace does not exist. * @throws ConstraintViolationException if the operation would violate a * node-type or other implementation-specific constraint. * @throws VersionException if the parent node of destAbsPath is * versionable and checked-in, or is non-versionable but its nearest versionable ancestor is * checked-in. This exception will also be thrown if removeExisting is true, * and a UUID conflict occurs that would require the moving and/or altering of a node that is checked-in. * @throws AccessDeniedException if the current session does not have * sufficient access rights to complete the operation. * @throws PathNotFoundException if the node at srcAbsPath or * the parent of the new node at destAbsPath does not exist. * @throws ItemExistsException if a property already exists at * destAbsPath or a node already exist there, and same name * siblings are not allowed or if removeExisting is false and a * UUID conflict occurs. * @throws LockException if a lock prevents the clone. * @throws RepositoryException if the last element of destAbsPath * has an index or if another error occurs. */ public function clone_( $srcAbsPath, $destAbsPath, $srcWorkspace = null, $removeExisting = null ); /** * Moves the node at srcAbsPath (and its entire subtree) to the * new location at destAbsPath. If successful, * the change is persisted immediately, there is no need to call save. * Note that this is in contrast to {@link Session#move} which operates within the * transient space and hence requires a save. *

* The destAbsPath provided must not * have an index on its final element. If it does then a RepositoryException * is thrown. Strictly speaking, the destAbsPath parameter is actually an absolute path * to the parent node of the new location, appended with the new name desired for the * moved node. It does not specify a position within the child node * ordering. If ordering is supported by the node type of * the parent node of the new location, then the newly moved node is appended to the end of the * child node list. *

* This method cannot be used to move just an individual property by itself. * It moves an entire node and its subtree (including, of course, any properties contained therein). *

* A ConstraintViolationException is thrown if the operation would violate a node-type * or other implementation-specific constraint. *

* A VersionException is thrown if the parent node of destAbsPath * or the parent node of srcAbsPath is versionable and checked-in, or is * non-versionable but its nearest versionable ancestor is checked-in. *

* An AccessDeniedException is thrown if the current session (i.e. the session that * was used to acquire this Workspace object) does not have sufficient access rights * to complete the operation. *

* A PathNotFoundException is thrown if the node at srcAbsPath or the * parent of the new node at destAbsPath does not exist. *

* An ItemExistException is thrown if a property already exists at * destAbsPath or a node already exist there, and same name * siblings are not allowed. *

* A LockException if a lock prevents the move. * * @param srcAbsPath the path of the node to be moved. * @param destAbsPath the location to which the node at srcAbsPath * is to be moved. * @throws ConstraintViolationException if the operation would violate a * node-type or other implementation-specific constraint * @throws VersionException if the parent node of destAbsPath * or the parent node of srcAbsPath is versionable and checked-in, * or is non-versionable but its nearest versionable ancestor is checked-in. * @throws AccessDeniedException if the current session (i.e. the session that * was used to aqcuire this Workspace object) does not have * sufficient access rights to complete the operation. * @throws PathNotFoundException if the node at srcAbsPath or * the parent of the new node at destAbsPath does not exist. * @throws ItemExistsException if a property already exists at * destAbsPath or a node already exist there, and same name * siblings are not allowed. * @throws LockException if a lock prevents the move. * @throws RepositoryException if the last element of destAbsPath * has an index or if another error occurs. */ public function move( $srcAbsPath, $destAbsPath ); /** * Restores a set of versions at once. Used in cases where a "chicken and egg" problem of * mutually referring REFERENCE properties would prevent the restore in any * serial order. *

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

* The following restrictions apply to the set of versions specified: *

* If S is the set of versions being restored simultaneously, *

*
1. * For every version V in S that corresponds to * a missing node, there must also be a parent of V in S. *
*
2. * S must contain at least one version that corresponds to * an existing node in the workspace. *
*

* The versionable nodes in this workspace that correspond to the versions being restored * define a set of (one or more) subtrees. A UUID collision occurs when this workspace * contains a node outside these subtrees that has the same UUID as one of the nodes * that would be introduced by the restore operation into one of these subtrees. * The result in such a case is governed by the removeExisting flag. * If removeExisting is true then the incoming node takes precedence, * and the existing node (and its subtree) is removed. If removeExisting * is false then a ItemExistsException is thrown and no changes are made. * Note that this applies not only to cases where the restored * node itself conflicts with an existing node but also to cases where a conflict occurs with any * node that would be introduced into the workspace by the restore operation. In particular, conflicts * involving subnodes of the restored node that have OnParentVersion settings of * COPY or VERSION are also governed by the removeExisting flag. *

* An UnsupportedRepositoryOperationException is thrown if versioning is not supported. *

* 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. * * @param versions The set of versions to be restored * @param removeExisting governs what happens on UUID collision. * * @throws ItemExistsException if removeExisting is false * and a UUID collision occurs with a node being restored. * @throws UnsupportedRepositoryOperationException if versioning is not supported. * @throws VersionException if the set of versions to be restored is such that the * original path location of one or more of the versions cannot be determined or * if the restore would change the state of a existing verisonable * node that is currently checked-in. * @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. */ public function restore( /* Version */ $versions, $removeExisting ); /** * Gets the QueryManager. * Returns the QueryManager object, through search methods are accessed. * * @throws RepositoryException if an error occurs. * @return the QueryManager object. */ public function getQueryManager(); /** * Returns the NamespaceRegistry object, which is used to access information * and (in level 2) set the mapping between namespace prefixes and URIs. * * @throws RepositoryException if an error occurs. * @return the NamespaceRegistry. */ public function getNamespaceRegistry(); /** * Returns the NodeTypeManager through which node type * information can be queried. There is one node type registry per * repository, therefore the NodeTypeManager is not * workspace-specific; it provides introspection methods for the * global, repository-wide set of available node types. * * @throws RepositoryException if an error occurs. * @return a NodeTypeManager object. */ public function getNodeTypeManager(); /** * If the the implemention supports observation * this method returns the ObservationManager object; * otherwise it throws an UnsupportedRepositoryOperationException. * * @throws UnsupportedRepositoryOperationException if the implementation does not support observation. * @throws RepositoryException if an error occurs. * * @return an ObservationManager object. */ public function getObservationManager(); /** * Returns an string array containing the names of all workspaces * in this repository that are accessible to this user, given the * Credentials that were used to get the Session * tied to this Workspace. *

* In order to access one of the listed workspaces, the user performs another * Repository.login, specifying the name of the desired workspace, * and receives a new Session object. * * @return string array of names of accessible workspaces. * @throws RepositoryException */ public function getAccessibleWorkspaceNames(); /** * Returns a org.xml.sax.ContentHandler which can be used to push SAX events into the repository. * If the incoming XML stream (in the form of SAX events) does not appear to be a JCR system view XML document then it is * interpreted as a document view XML document. *

* The incoming XML is deserialized into a subtree of items immediately below the node at * parentAbsPath. *

* The special properties jcr:primaryType and jcr:mixinTypes are * taken into account during deserialization in order to determine the node types of the newly created nodes. *

* This method simply returns the ContentHandler without altering the state of the * repsoitory; the actual deserialization is done through the methods of the ContentHandler. * Invalid XML data will cause the ContentHandler to throw a SAXException. *

* As SAX events are fed into the ContentHandler, changes are made directly at the * workspace level, without going through the Session. As a result, there is not need * to call save. The advantage of this * direct-to-workspace method is that a large import will not result in a large cache of pending * nodes in the Session. The disadvantage is that structures that violate node type constraints * cannot be imported, fixed and then saved. Instead, a constraint violation will cause the * ContentHandler to throw a SAXException. See Session.getImportContentHandler for a version of * this method that does go through the Session. *

* The flag uuidBehavior governs how the UUIDs of incoming (deserialized) nodes are * handled. There are four options: *

*
• {@link #IMPORT_UUID_CREATE_NEW}: Incoming referenceable nodes are assigned newly * created UUIDs upon additon to the workspace. As a result UUID collisions never occur. *
• {@link #IMPORT_UUID_COLLISION_REMOVE_EXISTING}: If an incoming referenceable node * has the same UUID as a node already existing in the workspace, then the already exisitng node * (and its subtree) is removed from wherever it may be in the workspace before the incoming node * is added. Note that this can result in nodes "disappearing" from locations in the worksapce that * are remote from the location to which the incoming subtree is being written. *
• {@link #IMPORT_UUID_COLLISION_REPLACE_EXISTING}: If an incoming referenceable node * has the same UUID as a node already existing in the workspace then the already existing node * is replaced by the incoming node in the same position as the existing node. Note that this may * result in the incoming subtree being disaggregated and "spread around" to different locations * in the workspace. In the most extreme case this behavior may result in no node at all * being added as child of parentAbsPath. This will occur if the topmost element * of the incoming XML has the same UUID as an existing node elsewhere in the workspace. *
• {@link #IMPORT_UUID_COLLISION_THROW}: If an incoming referenceable node * has the same UUID as a node already existing in the workspace then a SAXException * is thrown by the returned ContentHandler during deserialization. *

* A SAXException will also be thrown by the returned ContentHandler * during deserialzation if uuidBehavior is set to * IMPORT_UUID_COLLISION_REMOVE_EXISTING and an incoming node has the same UUID as * the node at parentAbsPath or one of its ancestors. *

* A PathNotFoundException is thrown if no node exists at parentAbsPath. *

* A ConstraintViolationException is thrown if the new subtree cannot be added to the node at * parentAbsPath due to node-type or other implementation-specific constraints, and this can * be determined before the first SAX event is sent. Unlike {@link Session#getImportContentHandler}, * this method also enforces node type constraints by throwing SAXExceptions during * deserialization. *

* A VersionException is thrown if the node at parentAbsPath is versionable * and checked-in, or is non-versionable but its nearest versionable ancestor is checked-in. *

* A LockException is thrown if a lock prevents the addition ofthe subtree. *

* A RepositoryException is thrown if another error occurs. * * @param parentAbsPath the absolute path of a node under which (as child) the imported subtree will be built. * @param uuidBehavior a four-value flag that governs how incoming UUIDs are handled. * @return an org.xml.sax.ContentHandler whose methods may be called to feed SAX events into the deserializer. * * @throws PathNotFoundException if no node exists at parentAbsPath. * @throws ConstraintViolationException if the new subtree cannot be added to the node at * parentAbsPath due to node-type or other implementation-specific constraints, * and this can be determined before the first SAX event is sent. * @throws VersionException if the node at parentAbsPath is versionable * and checked-in, or is non-versionable but its nearest versionable ancestor is checked-in. * @throws LockException if a lock prevents the addition of the subtree. * @throws RepositoryException if another error occurs. */ public function getImportContentHandler( $parentAbsPath, $uuidBehavior ); /** * Deserializes an XML document and adds the resulting item subtree as a child of the node at * parentAbsPath. *

* If the incoming XML stream does not appear to be a JCR system view XML document then it is interpreted as a * document view XML document. *

* The special properties jcr:primaryType and jcr:mixinTypes are * taken into account during deserialization in order to determine the node types of the newly * created nodes. *

* Changes are made directly at the workspace level, without going through the Session. * As a result, there is not need to call save. The advantage of this * direct-to-workspace method is that a large import will not result in a large cache of * pending nodes in the Session. The disadvantage is that invalid data cannot * be imported, fixed and then saved. Instead, invalid data will cause this method to throw an * InvalidSerializedDataException. See Session.importXML for * a version of this method that does go through the Session. *

* The flag uuidBehavior governs how the UUIDs of incoming (deserialized) nodes are * handled. There are four options: *

*
• {@link #IMPORT_UUID_CREATE_NEW}: Incoming referenceable nodes are assigned newly * created UUIDs upon additon to the workspace. As a result UUID collisions never occur. *
• {@link #IMPORT_UUID_COLLISION_REMOVE_EXISTING}: If an incoming referenceable node * has the same UUID as a node already existing in the workspace then the already exisitng node * (and its subtree) is removed from wherever it may be in the workspace before the incoming node * is added. Note that this can result in nodes "disappearing" from locations in the worksapce that * are remote from the location to which the incoming subtree is being written. If an incoming node * has the same UUID as the existing root node of this workspace then *
• {@link #IMPORT_UUID_COLLISION_REPLACE_EXISTING}: If an incoming referenceable node * has the same UUID as a node already existing in the workspace then the already existing node * is replaced by the incoming node in the same position as the existing node. Note that this may * result in the incoming subtree being disaggregated and "spread around" to different locations * in the workspace. In the most extreme edge case this behavior may result in no node at all * being added as child of parentAbsPath. This will occur if the topmost element * of the incoming XML has the same UUID as an existing node elsewhere in the workspace. *
• {@link #IMPORT_UUID_COLLISION_THROW}: If an incoming referenceable node * has the same UUID as a node already existing in the workspace then an ItemExistsException * is thrown. *

* An IOException is thrown if an I/O error occurs. *

* If no node exists at parentAbsPath, a PathNotFoundException is thrown. *

* An ItemExisitsException is thrown if the top-most element of the incoming XML would deserialize * to a node with the same name as an existing child of parentAbsPath and that * child does not allow same-name siblings, or if a uuidBehavior is set to * IMPORT_UUID_COLLISION_THROW and a UUID collision occurs. *

* If node-type or other implementation-specific constraints * prevent the addition of the subtree, a ConstraintViolationException is thrown. *

* A ConstraintViolationException will also be thrown if uuidBehavior * is set to IMPORT_UUID_COLLISION_REMOVE_EXISTING and an incoming node has the same * UUID as the node at parentAbsPath or one of its ancestors. *

* A VersionException is thrown if the node at parentAbsPath is versionable * and checked-in, or is non-versionable but its nearest versionable ancestor is checked-in. *

* A LockException is thrown if a lock prevents the addition of the subtree. * * @param parentAbsPath the absolute path of the node below which the deserialized subtree is added. * @param in The Inputstream from which the XML to be deserilaized is read. * @param uuidBehavior a four-value flag that governs how incoming UUIDs are handled. * * @throws IOException if an error during an I/O operation occurs. * @throws PathNotFoundException if no node exists at parentAbsPath. * @throws ConstraintViolationException if node-type or other implementation-specific constraints * prevent the addition of the subtree or if uuidBehavior * is set to IMPORT_UUID_COLLISION_REMOVE_EXISTING and an incoming node has the same * UUID as the node at parentAbsPath or one of its ancestors. * @throws VersionException if the node at parentAbsPath is versionable * and checked-in, or is non-versionable but its nearest versionable ancestor is checked-in. * @throws InvalidSerializedDataException if incoming stream is not a valid XML document. * @throws ItemExistsException if the top-most element of the incoming XML would deserialize * to a node with the same name as an existing child of parentAbsPath and that * child does not allow same-name siblings, or if a uuidBehavior is set to * IMPORT_UUID_COLLISION_THROW and a UUID collision occurs. * @throws LockException if a lock prevents the addition of the subtree. * @throws RepositoryException is another error occurs. */ public function importXML( $parentAbsPath, $in, $uuidBehavior ); } ?>