jackrabbit-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ang...@apache.org
Subject svn commit: r705243 - in /jackrabbit/trunk/jackrabbit-core/src/main/java/org/apache/jackrabbit/core: SessionImpl.java WorkspaceImpl.java
Date Thu, 16 Oct 2008 13:49:36 GMT
Author: angela
Date: Thu Oct 16 06:49:35 2008
New Revision: 705243

URL: http://svn.apache.org/viewvc?rev=705243&view=rev
Log:
JCR-1817 : Misleading method naming with Workspace and Session (move283, copy283, clone283)

Modified:
    jackrabbit/trunk/jackrabbit-core/src/main/java/org/apache/jackrabbit/core/SessionImpl.java
    jackrabbit/trunk/jackrabbit-core/src/main/java/org/apache/jackrabbit/core/WorkspaceImpl.java

Modified: jackrabbit/trunk/jackrabbit-core/src/main/java/org/apache/jackrabbit/core/SessionImpl.java
URL: http://svn.apache.org/viewvc/jackrabbit/trunk/jackrabbit-core/src/main/java/org/apache/jackrabbit/core/SessionImpl.java?rev=705243&r1=705242&r2=705243&view=diff
==============================================================================
--- jackrabbit/trunk/jackrabbit-core/src/main/java/org/apache/jackrabbit/core/SessionImpl.java (original)
+++ jackrabbit/trunk/jackrabbit-core/src/main/java/org/apache/jackrabbit/core/SessionImpl.java Thu Oct 16 06:49:35 2008
@@ -878,7 +878,173 @@
             throws ItemExistsException, PathNotFoundException,
             VersionException, ConstraintViolationException, LockException,
             RepositoryException {
-        move283(srcAbsPath, destAbsPath);
+        // check sanity of this session
+        sanityCheck();
+
+        // check paths & get node instances
+
+        Path srcPath;
+        Path.Element srcName;
+        Path srcParentPath;
+        NodeImpl targetNode;
+        NodeImpl srcParentNode;
+        try {
+            srcPath = getQPath(srcAbsPath).getNormalizedPath();
+            if (!srcPath.isAbsolute()) {
+                throw new RepositoryException("not an absolute path: " + srcAbsPath);
+            }
+            srcName = srcPath.getNameElement();
+            srcParentPath = srcPath.getAncestor(1);
+            targetNode = getItemManager().getNode(srcPath);
+            srcParentNode = getItemManager().getNode(srcParentPath);
+        } catch (AccessDeniedException ade) {
+            throw new PathNotFoundException(srcAbsPath);
+        } catch (NameException e) {
+            String msg = srcAbsPath + ": invalid path";
+            log.debug(msg);
+            throw new RepositoryException(msg, e);
+        }
+
+        Path destPath;
+        Path.Element destName;
+        Path destParentPath;
+        NodeImpl destParentNode;
+        try {
+            destPath = getQPath(destAbsPath).getNormalizedPath();
+            if (!destPath.isAbsolute()) {
+                throw new RepositoryException("not an absolute path: " + destAbsPath);
+            }
+            if (srcPath.isAncestorOf(destPath)) {
+                String msg = destAbsPath + ": invalid destination path (cannot be descendant of source path)";
+                log.debug(msg);
+                throw new RepositoryException(msg);
+            }
+            destName = destPath.getNameElement();
+            destParentPath = destPath.getAncestor(1);
+            destParentNode = getItemManager().getNode(destParentPath);
+        } catch (AccessDeniedException ade) {
+            throw new PathNotFoundException(destAbsPath);
+        } catch (NameException e) {
+            String msg = destAbsPath + ": invalid path";
+            log.debug(msg);
+            throw new RepositoryException(msg, e);
+        }
+
+        if (hierMgr.isShareAncestor(targetNode.getNodeId(), destParentNode.getNodeId())) {
+            String msg = destAbsPath + ": invalid destination path (share cycle detected)";
+            log.debug(msg);
+            throw new RepositoryException(msg);
+        }
+
+        int ind = destName.getIndex();
+        if (ind > 0) {
+            // subscript in name element
+            String msg = destAbsPath + ": invalid destination path (subscript in name element is not allowed)";
+            log.debug(msg);
+            throw new RepositoryException(msg);
+        }
+
+        // verify that both source and destination parent nodes are checked-out
+        if (!srcParentNode.internalIsCheckedOut()) {
+            String msg = srcAbsPath + ": cannot move a child of a checked-in node";
+            log.debug(msg);
+            throw new VersionException(msg);
+        }
+        if (!destParentNode.internalIsCheckedOut()) {
+            String msg = destAbsPath + ": cannot move a target to a checked-in node";
+            log.debug(msg);
+            throw new VersionException(msg);
+        }
+
+        // check for name collisions
+
+        NodeImpl existing = null;
+        try {
+            existing = getItemManager().getNode(destPath);
+            // there's already a node with that name:
+            // check same-name sibling setting of existing node
+            if (!existing.getDefinition().allowsSameNameSiblings()) {
+                throw new ItemExistsException(
+                        "Same name siblings are not allowed: " + existing);
+            }
+        } catch (AccessDeniedException ade) {
+            // FIXME by throwing ItemExistsException we're disclosing too much information
+            throw new ItemExistsException(destAbsPath);
+        } catch (PathNotFoundException pnfe) {
+            // no name collision, fall through
+        }
+
+        // check constraints
+
+        // get applicable definition of target node at new location
+        NodeTypeImpl nt = (NodeTypeImpl) targetNode.getPrimaryNodeType();
+        NodeDefinitionImpl newTargetDef;
+        try {
+            newTargetDef = destParentNode.getApplicableChildNodeDefinition(destName.getName(), nt.getQName());
+        } catch (RepositoryException re) {
+            String msg = destAbsPath + ": no definition found in parent node's node type for new node";
+            log.debug(msg);
+            throw new ConstraintViolationException(msg, re);
+        }
+        // if there's already a node with that name also check same-name sibling
+        // setting of new node; just checking same-name sibling setting on
+        // existing node is not sufficient since same-name sibling nodes don't
+        // necessarily have identical definitions
+        if (existing != null && !newTargetDef.allowsSameNameSiblings()) {
+            throw new ItemExistsException(
+                    "Same name siblings not allowed: " + existing);
+        }
+
+        // check protected flag of old & new parent
+        if (destParentNode.getDefinition().isProtected()) {
+            String msg = destAbsPath + ": cannot add a child node to a protected node";
+            log.debug(msg);
+            throw new ConstraintViolationException(msg);
+        }
+        if (srcParentNode.getDefinition().isProtected()) {
+            String msg = srcAbsPath + ": cannot remove a child node from a protected node";
+            log.debug(msg);
+            throw new ConstraintViolationException(msg);
+        }
+
+        // check lock status
+        srcParentNode.checkLock();
+        destParentNode.checkLock();
+
+        NodeId targetId = targetNode.getNodeId();
+        int index = srcName.getIndex();
+        if (index == 0) {
+            index = 1;
+        }
+
+        if (srcParentNode.isSame(destParentNode)) {
+            // do rename
+            destParentNode.renameChildNode(srcName.getName(), index, targetId, destName.getName());
+        } else {
+            // check shareable case
+            if (((NodeState) targetNode.getItemState()).isShareable()) {
+                String msg = "Moving a shareable node is not supported.";
+                log.debug(msg);
+                throw new UnsupportedRepositoryOperationException(msg);
+            }
+
+            // do move:
+            // 1. remove child node entry from old parent
+            NodeState srcParentState =
+                    (NodeState) srcParentNode.getOrCreateTransientItemState();
+            srcParentState.removeChildNodeEntry(srcName.getName(), index);
+            // 2. re-parent target node
+            NodeState targetState =
+                    (NodeState) targetNode.getOrCreateTransientItemState();
+            targetState.setParentId(destParentNode.getNodeId());
+            // 3. add child node entry to new parent
+            NodeState destParentState =
+                    (NodeState) destParentNode.getOrCreateTransientItemState();
+            destParentState.addChildNodeEntry(destName.getName(), targetId);
+        }
+
+        // change definition of target
+        targetNode.onRedefine(newTargetDef.unwrap().getId());
     }
 
     /**
@@ -1373,259 +1539,6 @@
         return retentionManager;
     }
 
-    //-----------------------------------< Session methods changed in JSR 283 >
-    /**
-     * Moves the node at <code>srcAbsPath</code> (and its entire subtree) to the
-     * new location at <code>destAbsPath</code>. Returns the path of the node at
-     * its new position. Note that the returned path will indicate the resulting
-     * same-name sibling index of the destination (if necessary), unlike the
-     * supplied <code>destAbsPath</code> parameter (see below).
-     * <p>
-     * In order to persist the change, a <code>save</code>
-     * must be called on either the session or a common ancestor to both the source and destination locations.
-     * <p/>
-     * The identifiers of referenceable nodes must not be changed by a
-     * <code>move</code>. The identifiers of non-referenceable nodes <i>may</i> change.
-     * <p/>
-     * A <code>ConstraintViolationException</code> is thrown either immediately or on <code>save</code>
-     * if performing this operation would violate a node type or implementation-specific constraint.
-     * Implementations may differ on when this validation is performed.
-     * <p>
-     * As well, a <code>ConstraintViolationException</code> will be thrown on
-     * <code>save</code> if an attempt is made to seperately <code>save</code>
-     * either the source or destination node.
-     * <p>
-     * Note that this behaviour differs from that of
-     * {@link Workspace#move}, which operates directly in the persistent
-     * workspace and does not require a <code>save</code>.
-     * <p/>
-     * The <code>destAbsPath</code> provided must not have an index on its final
-     * element. If it does then a <code>RepositoryException</code> is thrown.
-     * Strictly speaking, the <code>destAbsPath</code> parameter is actually an
-     * <i>absolute path</i> to the parent node of the new location, appended
-     * with the new <i>name</i> desired for the moved node. It does not specify
-     * a position within the child node ordering (if such ordering is
-     * supported). If ordering is supported by the node type of the parent node
-     * of the new location, then the newly moved node is appended to the end of
-     * the child node list. The resulting position within a same-name sibling set
-     * can, however, be determined from the path returned by this method, which
-     * will include an index if one is required.
-     * <p/>
-     * 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).
-     * <p/>
-     * If no node exists at <code>srcAbsPath</code> or no node exists one level above <code>destAbsPath</code>
-     * (in other words, there is no node that will serve as the parent of the moved item) then a
-     * <code>PathNotFoundException</code> is thrown either immediately or on <code>save</code>.
-     * Implementations may differ on when this validation is performed.
-     * <p/>
-     * An <code>ItemExistsException</code> is thrown either immediately or on <code>save</code>
-     * if a node already exists at <code>destAbsPath</code> and same-name siblings are not allowed.
-     * Implementations may differ on when this validation is performed.
-     * <p/>
-     * Note that if a property already exists at <code>destAbsPath</code>, the
-     * operation succeeds, since a node may have a child node and property with
-     * the same name.
-     * <p/>
-     * A <code>VersionException</code> is thrown either immediately or on <code>save</code>
-     * if the parent node of <code>destAbsPath</code> or the parent node of <code>srcAbsPath] is versionable and
-     * checked-in, or is non-versionable and its nearest versionable ancestor is checked-in.
-     * Implementations may differ on when this validation is performed.
-     * <p/>
-     * A <code>LockException</code> is thrown either immediately or on <code>save</code>
-     * if a lock prevents the <code>move</code>. Implementations may differ on when this validation is performed.
-     *
-     * @param srcAbsPath the root of the subtree to be moved.
-     * @param destAbsPath the location to which the subtree is to be moved.
-     * @return the path of the node at its new position.
-     * @throws ItemExistsException if a node already exists at <code>destAbsPath</code>
-     * and same-name siblings are not allowed.
-     * @throws PathNotFoundException if either <code>srcAbsPath</code> or <code>destAbsPath</code> cannot be found and this
-     * implementation performs this validation immediately instead of waiting until <code>save</code>.
-     * @throws VersionException if the parent node of <code>destAbsPath</code> or the parent node of <code>srcAbsPath</code>
-     * is versionable and checked-in, or or is non-verionable and its nearest versionable ancestor is checked-in and this
-     * implementation performs this validation immediately instead of waiting until <code>save</code>.
-     * @throws ConstraintViolationException if a node-type or other constraint violation is detected immediately and this
-     * implementation performs this validation immediately instead of waiting until <code>save</code>.
-     * @throws LockException if the move operation would violate a lock and this
-     * implementation performs this validation immediately instead of waiting until <code>save</code>.
-     * @throws RepositoryException if the last element of <code>destAbsPath</code> has an index or if another error occurs.
-     */
-    public String move283(String srcAbsPath, String destAbsPath)
-            throws ItemExistsException, PathNotFoundException, VersionException,
-            ConstraintViolationException, LockException, RepositoryException {
-        // check sanity of this session
-        sanityCheck();
-
-        // check paths & get node instances
-
-        Path srcPath;
-        Path.Element srcName;
-        Path srcParentPath;
-        NodeImpl targetNode;
-        NodeImpl srcParentNode;
-        try {
-            srcPath = getQPath(srcAbsPath).getNormalizedPath();
-            if (!srcPath.isAbsolute()) {
-                throw new RepositoryException("not an absolute path: " + srcAbsPath);
-            }
-            srcName = srcPath.getNameElement();
-            srcParentPath = srcPath.getAncestor(1);
-            targetNode = getItemManager().getNode(srcPath);
-            srcParentNode = getItemManager().getNode(srcParentPath);
-        } catch (AccessDeniedException ade) {
-            throw new PathNotFoundException(srcAbsPath);
-        } catch (NameException e) {
-            String msg = srcAbsPath + ": invalid path";
-            log.debug(msg);
-            throw new RepositoryException(msg, e);
-        }
-
-        Path destPath;
-        Path.Element destName;
-        Path destParentPath;
-        NodeImpl destParentNode;
-        try {
-            destPath = getQPath(destAbsPath).getNormalizedPath();
-            if (!destPath.isAbsolute()) {
-                throw new RepositoryException("not an absolute path: " + destAbsPath);
-            }
-            if (srcPath.isAncestorOf(destPath)) {
-                String msg = destAbsPath + ": invalid destination path (cannot be descendant of source path)";
-                log.debug(msg);
-                throw new RepositoryException(msg);
-            }
-            destName = destPath.getNameElement();
-            destParentPath = destPath.getAncestor(1);
-            destParentNode = getItemManager().getNode(destParentPath);
-        } catch (AccessDeniedException ade) {
-            throw new PathNotFoundException(destAbsPath);
-        } catch (NameException e) {
-            String msg = destAbsPath + ": invalid path";
-            log.debug(msg);
-            throw new RepositoryException(msg, e);
-        }
-
-        if (hierMgr.isShareAncestor(targetNode.getNodeId(), destParentNode.getNodeId())) {
-            String msg = destAbsPath + ": invalid destination path (share cycle detected)";
-            log.debug(msg);
-            throw new RepositoryException(msg);
-        }
-
-        int ind = destName.getIndex();
-        if (ind > 0) {
-            // subscript in name element
-            String msg = destAbsPath + ": invalid destination path (subscript in name element is not allowed)";
-            log.debug(msg);
-            throw new RepositoryException(msg);
-        }
-
-        // verify that both source and destination parent nodes are checked-out
-        if (!srcParentNode.internalIsCheckedOut()) {
-            String msg = srcAbsPath + ": cannot move a child of a checked-in node";
-            log.debug(msg);
-            throw new VersionException(msg);
-        }
-        if (!destParentNode.internalIsCheckedOut()) {
-            String msg = destAbsPath + ": cannot move a target to a checked-in node";
-            log.debug(msg);
-            throw new VersionException(msg);
-        }
-
-        // check for name collisions
-
-        NodeImpl existing = null;
-        try {
-            existing = getItemManager().getNode(destPath);
-            // there's already a node with that name:
-            // check same-name sibling setting of existing node
-            if (!existing.getDefinition().allowsSameNameSiblings()) {
-                throw new ItemExistsException(
-                        "Same name siblings are not allowed: " + existing);
-            }
-        } catch (AccessDeniedException ade) {
-            // FIXME by throwing ItemExistsException we're disclosing too much information
-            throw new ItemExistsException(destAbsPath);
-        } catch (PathNotFoundException pnfe) {
-            // no name collision, fall through
-        }
-
-        // check constraints
-
-        // get applicable definition of target node at new location
-        NodeTypeImpl nt = (NodeTypeImpl) targetNode.getPrimaryNodeType();
-        NodeDefinitionImpl newTargetDef;
-        try {
-            newTargetDef = destParentNode.getApplicableChildNodeDefinition(destName.getName(), nt.getQName());
-        } catch (RepositoryException re) {
-            String msg = destAbsPath + ": no definition found in parent node's node type for new node";
-            log.debug(msg);
-            throw new ConstraintViolationException(msg, re);
-        }
-        // if there's already a node with that name also check same-name sibling
-        // setting of new node; just checking same-name sibling setting on
-        // existing node is not sufficient since same-name sibling nodes don't
-        // necessarily have identical definitions
-        if (existing != null && !newTargetDef.allowsSameNameSiblings()) {
-            throw new ItemExistsException(
-                    "Same name siblings not allowed: " + existing);
-        }
-
-        // check protected flag of old & new parent
-        if (destParentNode.getDefinition().isProtected()) {
-            String msg = destAbsPath + ": cannot add a child node to a protected node";
-            log.debug(msg);
-            throw new ConstraintViolationException(msg);
-        }
-        if (srcParentNode.getDefinition().isProtected()) {
-            String msg = srcAbsPath + ": cannot remove a child node from a protected node";
-            log.debug(msg);
-            throw new ConstraintViolationException(msg);
-        }
-
-        // check lock status
-        srcParentNode.checkLock();
-        destParentNode.checkLock();
-
-        NodeId targetId = targetNode.getNodeId();
-        int index = srcName.getIndex();
-        if (index == 0) {
-            index = 1;
-        }
-
-        if (srcParentNode.isSame(destParentNode)) {
-            // do rename
-            destParentNode.renameChildNode(srcName.getName(), index, targetId, destName.getName());
-        } else {
-            // check shareable case
-            if (((NodeState) targetNode.getItemState()).isShareable()) {
-                String msg = "Moving a shareable node is not supported.";
-                log.debug(msg);
-                throw new UnsupportedRepositoryOperationException(msg);
-            }
-
-            // do move:
-            // 1. remove child node entry from old parent
-            NodeState srcParentState =
-                    (NodeState) srcParentNode.getOrCreateTransientItemState();
-            srcParentState.removeChildNodeEntry(srcName.getName(), index);
-            // 2. re-parent target node
-            NodeState targetState =
-                    (NodeState) targetNode.getOrCreateTransientItemState();
-            targetState.setParentId(destParentNode.getNodeId());
-            // 3. add child node entry to new parent
-            NodeState destParentState =
-                    (NodeState) destParentNode.getOrCreateTransientItemState();
-            destParentState.addChildNodeEntry(destName.getName(), targetId);
-        }
-
-        // change definition of target
-        targetNode.onRedefine(newTargetDef.unwrap().getId());
-
-        return targetNode.getPath();
-    }
-
     //-------------------------------------------------------------< Dumpable >
     /**
      * {@inheritDoc}

Modified: jackrabbit/trunk/jackrabbit-core/src/main/java/org/apache/jackrabbit/core/WorkspaceImpl.java
URL: http://svn.apache.org/viewvc/jackrabbit/trunk/jackrabbit-core/src/main/java/org/apache/jackrabbit/core/WorkspaceImpl.java?rev=705243&r1=705242&r2=705243&view=diff
==============================================================================
--- jackrabbit/trunk/jackrabbit-core/src/main/java/org/apache/jackrabbit/core/WorkspaceImpl.java (original)
+++ jackrabbit/trunk/jackrabbit-core/src/main/java/org/apache/jackrabbit/core/WorkspaceImpl.java Thu Oct 16 06:49:35 2008
@@ -539,7 +539,50 @@
             throws NoSuchWorkspaceException, ConstraintViolationException,
             VersionException, AccessDeniedException, PathNotFoundException,
             ItemExistsException, LockException, RepositoryException {
-        clone283(srcWorkspace, srcAbsPath, destAbsPath, removeExisting);
+        // check state of this instance
+        sanityCheck();
+
+        // check workspace name
+        if (getName().equals(srcWorkspace)) {
+            // clone to same workspace is allowed for mix:shareable nodes,
+            // but only if removeExisting is false
+            if (!removeExisting) {
+                internalClone(srcAbsPath, destAbsPath);
+                return;
+            }
+            // same as current workspace
+            String msg = srcWorkspace + ": illegal workspace (same as current)";
+            log.debug(msg);
+            throw new RepositoryException(msg);
+        }
+
+        // check authorization for specified workspace
+        if (!session.getAccessManager().canAccess(srcWorkspace)) {
+            throw new AccessDeniedException("not authorized to access " + srcWorkspace);
+        }
+
+        // clone (i.e. pull) subtree at srcAbsPath from srcWorkspace
+        // to 'this' workspace at destAbsPath
+
+        SessionImpl srcSession = null;
+        try {
+            // create session on other workspace for current subject
+            // (may throw NoSuchWorkspaceException and AccessDeniedException)
+            srcSession = rep.createSession(session.getSubject(), srcWorkspace);
+            WorkspaceImpl srcWsp = (WorkspaceImpl) srcSession.getWorkspace();
+
+            // do cross-workspace copy
+            int mode = BatchedItemOperations.CLONE;
+            if (removeExisting) {
+                mode = BatchedItemOperations.CLONE_REMOVE_EXISTING;
+            }
+            internalCopy(srcAbsPath, srcWsp, destAbsPath, mode);
+        } finally {
+            if (srcSession != null) {
+                // we don't need the other session anymore, logout
+                srcSession.logout();
+            }
+        }
     }
 
     /**
@@ -549,7 +592,11 @@
             throws ConstraintViolationException, VersionException,
             AccessDeniedException, PathNotFoundException, ItemExistsException,
             LockException, RepositoryException {
-        copy283(srcAbsPath, destAbsPath);
+        // check state of this instance
+        sanityCheck();
+
+        // do intra-workspace copy
+        internalCopy(srcAbsPath, this, destAbsPath, BatchedItemOperations.COPY);
     }
 
     /**
@@ -559,7 +606,40 @@
             throws NoSuchWorkspaceException, ConstraintViolationException,
             VersionException, AccessDeniedException, PathNotFoundException,
             ItemExistsException, LockException, RepositoryException {
-        copy283(srcWorkspace, srcAbsPath, destAbsPath);
+
+        // check state of this instance
+        sanityCheck();
+
+        // check workspace name
+        if (getName().equals(srcWorkspace)) {
+            // same as current workspace, delegate to intra-workspace copy method
+            copy(srcAbsPath, destAbsPath);
+            return;
+        }
+
+        // check authorization for specified workspace
+        if (!session.getAccessManager().canAccess(srcWorkspace)) {
+            throw new AccessDeniedException("not authorized to access " + srcWorkspace);
+        }
+
+        // copy (i.e. pull) subtree at srcAbsPath from srcWorkspace
+        // to 'this' workspace at destAbsPath
+
+        SessionImpl srcSession = null;
+        try {
+            // create session on other workspace for current subject
+            // (may throw NoSuchWorkspaceException and AccessDeniedException)
+            srcSession = rep.createSession(session.getSubject(), srcWorkspace);
+            WorkspaceImpl srcWsp = (WorkspaceImpl) srcSession.getWorkspace();
+
+            // do cross-workspace copy
+            internalCopy(srcAbsPath, srcWsp, destAbsPath, BatchedItemOperations.COPY);
+        } finally {
+            if (srcSession != null) {
+                // we don't need the other session anymore, logout
+                srcSession.logout();
+            }
+        }
     }
 
     /**
@@ -569,7 +649,59 @@
             throws ConstraintViolationException, VersionException,
             AccessDeniedException, PathNotFoundException, ItemExistsException,
             LockException, RepositoryException {
-        move283(srcAbsPath, destAbsPath);
+        // check state of this instance
+        sanityCheck();
+
+        // intra-workspace move...
+
+        Path srcPath;
+        try {
+            srcPath = session.getQPath(srcAbsPath).getNormalizedPath();
+        } catch (NameException e) {
+            String msg = "invalid path: " + srcAbsPath;
+            log.debug(msg);
+            throw new RepositoryException(msg, e);
+        }
+        if (!srcPath.isAbsolute()) {
+            throw new RepositoryException("not an absolute path: " + srcAbsPath);
+        }
+
+        Path destPath;
+        try {
+            destPath = session.getQPath(destAbsPath).getNormalizedPath();
+        } catch (NameException e) {
+            String msg = "invalid path: " + destAbsPath;
+            log.debug(msg);
+            throw new RepositoryException(msg, e);
+        }
+        if (!destPath.isAbsolute()) {
+            throw new RepositoryException("not an absolute path: " + destAbsPath);
+        }
+
+        BatchedItemOperations ops = new BatchedItemOperations(
+                stateMgr, rep.getNodeTypeRegistry(), session.getLockManager(),
+                session, hierMgr);
+
+        try {
+            ops.edit();
+        } catch (IllegalStateException e) {
+            String msg = "unable to start edit operation";
+            log.debug(msg);
+            throw new RepositoryException(msg, e);
+        }
+
+        boolean succeeded = false;
+
+        try {
+            NodeId id = ops.move(srcPath, destPath);
+            ops.update();
+            succeeded = true;
+        } finally {
+            if (!succeeded) {
+                // update operation failed, cancel all modifications
+                ops.cancel();
+            }
+        }
     }
 
     /**
@@ -764,506 +896,6 @@
         return new LocalItemStateManager(shared, this, rep.getItemStateCacheFactory());
     }
 
-    //---------------------------------< Workspace methods changed in JSR 283 >
-    /**
-     * This method copies the node at <code>srcAbsPath</code> to the new
-     * location at <code>destAbsPath</code>. Returns the path of the node at its
-     * new position. Note that the returned path will indicate the resulting
-     * same-name sibling index of the destination, if necessary, unlike the
-     * supplied <code>destAbsPath</code> parameter (see below).
-     * <p/>
-     * This operation is performed entirely within the persistent workspace, it
-     * does not involve transient storage and therefore does not require a
-     * <code>save</code>.
-     * <p/>
-     * The new copies of nodes are automatically given new identifiers and
-     * referenceable nodes in particular are always given new referenceable
-     * identifiers.
-     * <p/>
-     * When the source subtree in a <code>copy</code> operation includes both a reference
-     * property (<code>P</code>) and the node to which it refers (<code>N</code>)
-     * then not only does the new copy of the referenceable node (<code>N'<code>)
-     * get a new identifier but the new copy of the reference property (<code>P'</code>)
-     * is changed so that it points to <code>N'</code>, thus preserving the
-     * reference within the subtree.
-     * <p/>
-     * The <code>destAbsPath</code> provided must not have an index on its final
-     * element. If it does then a <code>RepositoryException</code> is thrown.
-     * Strictly speaking, the <code>destAbsPath</code> parameter is actually an
-     * <i>absolute path</i> to the parent node of the new location, appended
-     * with the new <i>name</i> desired for the copied node. It does not specify
-     * a position within the child node ordering. If ordering is supported by
-     * the node type of the parent node of the new location, then the new copy
-     * of the node is appended to the end of the child node list. The resulting
-     * position within a same-name sibling set can, however, be determined from
-     * the path returned by this method, which will include an index if one is
-     * required.
-     * <p/>
-     * 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).
-     * <p/>
-     * A <code>ConstraintViolationException</code> is thrown if the operation would violate a node-type
-     * or other implementation-specific constraint.
-     * <p/>
-     * A <code>VersionException</code> is thrown if the parent node of <code>destAbsPath</code> is
-     * versionable and checked-in, or is non-versionable but its nearest versionable ancestor is
-     * checked-in.
-     * <p/>
-     * An <code>AccessDeniedException</code> is thrown if the current session (i.e. the session that
-     * was used to acquire this <code>Workspace</code> object) does not have sufficient access rights
-     * to complete the operation.
-     * <p/>
-     * A <code>PathNotFoundException</code> is thrown if the node at <code>srcAbsPath</code> or the
-     * parent of <code>destAbsPath</code> does not exist.
-     * <p/>
-     * An <code>ItemExistException</code> is thrown if a node already exists at
-     * <code>destAbsPath</code> and same-name siblings are not allowed. Note that
-     * if a property already exists at <code>destAbsPath</code>, the operation
-     * succeeds, since a node may have a child node and property with the same name.
-     * <p/>
-     * A <code>LockException</code> is thrown if a lock prevents the copy.
-     *
-     * @param srcAbsPath the path of the node to be copied.
-     * @param destAbsPath the location to which the node at <code>srcAbsPath</code>
-     * is to be copied.
-     * @return the path of the node at its new position.
-     * @throws ConstraintViolationException if the operation would violate a
-     * node-type or other implementation-specific constraint.
-     * @throws VersionException if the parent node of <code>destAbsPath</code> is
-     * versionable and checked-in, or is non-versionable but its nearest versionable ancestor 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 <code>srcAbsPath</code> or
-     * the parent of <code>destAbsPath</code> does not exist.
-     * @throws ItemExistsException if a node already exists at
-     * <code>destAbsPath</code> and same-name siblings are not allowed.
-     * @throws LockException if a lock prevents the copy.
-     * @throws RepositoryException if the last element of <code>destAbsPath</code>
-     * has an index or if another error occurs.
-     */
-    public String copy283(String srcAbsPath, String destAbsPath)
-            throws ConstraintViolationException, VersionException,
-            AccessDeniedException, PathNotFoundException, ItemExistsException,
-            LockException, RepositoryException {
-        // check state of this instance
-        sanityCheck();
-
-        // do intra-workspace copy
-        return internalCopy(srcAbsPath, this, destAbsPath, BatchedItemOperations.COPY);
-    }
-
-    /**
-     * This method copies the subtree at <code>srcAbsPath</code> in <code>srcWorkspace</code>
-     * to <code>destAbsPath</code> in <code>this</code> workspace. Returns the
-     * path of the node at its new position. Note that the returned path will
-     * indicate the resulting same-name sibling index of the destination,
-     * if necessary, unlike the supplied <code>destAbsPath</code> parameter
-     * (see below).
-     * <p/>
-     * Unlike <code>clone</code>, this method does assign new referenceable
-     * identifiers to the new copies of referenceable nodes. In the case of
-     * non-referenceable nodes, this method <i>may</i> assign new identifiers. This
-     * operation is performed entirely within the persistent workspace, it does
-     * not involve transient storage and therefore does not require a <code>save</code>.
-     * <p/>
-     * When the source subtree in a <code>copy</code> operation includes both a reference
-     * property (<code>P</code>) and the node to which it refers (<code>N</code>)
-     * then not only does the new copy of the referenceable node (<code>N'<code>)
-     * get a new identifier but the new copy of the reference property (<code>P'</code>)
-     * is changed so that it points to <code>N'</code>, thus preserving the
-     * reference within the subtree.
-     * <p/>
-     * The <code>destAbsPath</code> provided must not have an index on its final
-     * element. If it does then a <code>RepositoryException</code> is thrown.
-     * Strictly speaking, the <code>destAbsPath</code> parameter is actually an
-     * <i>absolute path</i> to the parent node of the new location, appended
-     * with the new <i>name</i> desired for the copied node. It does not specify
-     * a position within the child node ordering. If ordering is supported by
-     * the node type of the parent node of the new location, then the new copy
-     * of the node is appended to the end of the child node list. The resulting
-     * position within a same-name sibling set can, however, be determined from
-     * the path returned by this method, which will include an index if one is
-     * required.
-     * <p/>
-     * 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).
-     * <p/>
-     * A <code>NoSuchWorkspaceException</code> is thrown if <code>srcWorkspace</code> does not
-     * exist or if the current Session does not have permission to access it.
-     * <p/>
-     * A <code>ConstraintViolationException</code> is thrown if the operation would violate a node-type
-     * or other implementation-specific constraint.
-     * <p/>
-     * A <code>VersionException</code> is thrown if the parent node of <code>destAbsPath</code> is
-     * versionable and checked-in, or is non-versionable but its nearest versionable ancestor is
-     * checked-in.
-     * <p/>
-     * An <code>AccessDeniedException</code> is thrown if the current session (i.e. the session that
-     * was used to acquire this <code>Workspace</code> object) does not have sufficient access rights
-     * to complete the operation.
-     * <p/>
-     * A <code>PathNotFoundException</code> is thrown if the node at <code>srcAbsPath</code> in
-     * <code>srcWorkspace</code> or the parent of <code>destAbsPath</code> in this workspace does not exist.
-     * <p/>
-     * An <code>ItemExistException</code> is thrown if a node already exists at
-     * <code>destAbsPath</code> and same-name siblings are not allowed. Note that
-     * if a property already exists at <code>destAbsPath</code>, the operation
-     * succeeds, since a node may have a child node and property with the same name.
-     * <p/>
-     * A <code>LockException</code> is thrown if a lock prevents the copy.
-     *
-     * @param srcWorkspace the name of the workspace 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 <code>srcAbsPath</code>
-     * is to be copied in <code>this</code> workspace.
-     * @return the path of the node at its new position.
-     * @throws NoSuchWorkspaceException if <code>srcWorkspace</code> does not
-     * exist or if the current <code>Session</code> 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 <code>destAbsPath</code> 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
-     * <code>srcWorkspace</code> but otherwise does not have sufficient access rights to
-     * complete the operation.
-     * @throws PathNotFoundException if the node at <code>srcAbsPath</code> in <code>srcWorkspace</code> or
-     * the parent of <code>destAbsPath</code> in this workspace does not exist.
-     * @throws ItemExistsException if a node already exists at <code>destAbsPath</code>
-     * and same-name siblings are not allowed.
-     * @throws LockException if a lock prevents the copy.
-     * @throws RepositoryException if the last element of <code>destAbsPath</code>
-     * has an index or if another error occurs.
-     */
-    public String copy283(String srcWorkspace, String srcAbsPath, String destAbsPath)
-            throws NoSuchWorkspaceException, ConstraintViolationException,
-            VersionException, AccessDeniedException, PathNotFoundException,
-            ItemExistsException, LockException, RepositoryException {
-
-        // check state of this instance
-        sanityCheck();
-
-        // check workspace name
-        if (getName().equals(srcWorkspace)) {
-            // same as current workspace, delegate to intra-workspace copy method
-            return copy283(srcAbsPath, destAbsPath);
-        }
-
-        // check authorization for specified workspace
-        if (!session.getAccessManager().canAccess(srcWorkspace)) {
-            throw new AccessDeniedException("not authorized to access " + srcWorkspace);
-        }
-
-        // copy (i.e. pull) subtree at srcAbsPath from srcWorkspace
-        // to 'this' workspace at destAbsPath
-
-        SessionImpl srcSession = null;
-        try {
-            // create session on other workspace for current subject
-            // (may throw NoSuchWorkspaceException and AccessDeniedException)
-            srcSession = rep.createSession(session.getSubject(), srcWorkspace);
-            WorkspaceImpl srcWsp = (WorkspaceImpl) srcSession.getWorkspace();
-
-            // do cross-workspace copy
-            return internalCopy(srcAbsPath, srcWsp, destAbsPath, BatchedItemOperations.COPY);
-        } finally {
-            if (srcSession != null) {
-                // we don't need the other session anymore, logout
-                srcSession.logout();
-            }
-        }
-    }
-
-    /**
-     * Clones the subtree at the node <code>srcAbsPath</code> in <code>srcWorkspace</code> to the new location at
-     * <code>destAbsPath</code> in <code>this</code> workspace. Returns the path
-     * of the node at its new position. Note that the returned
-     * path will indicate the resulting same-name sibling index of the
-     * destination, if necessary, unlike the supplied <code>destAbsPath</code>
-     * parameter (see below).
-     * <p/>
-     * Unlike the signature of <code>copy</code> that copies between workspaces,
-     * this method <i>does not</i> assign new identifiers to the newly cloned nodes
-     * but preserves the identifiers of their respective source nodes. This applies
-     * to both referenceable and non-referenceable nodes.
-     * <p/>
-     * In some implementations there may be cases where preservation of a
-     * non-referenceable identifier is not possible, due to how non-referenceable
-     * identifiers are constructed in that implementation. In such a case this
-     * method will throw a <code>RepositoryException</code>.
-     * <p/>
-     * If <code>removeExisting</code> is true and an existing node in this workspace
-     * (the destination workspace) has the same identifier as a node being cloned from
-     * <code>srcWorkspace</code>, then the incoming node takes precedence, and the
-     * existing node (and its subtree) is removed. If <code>removeExisting</code>
-     * is false then an identifier collision causes this method to throw a
-     * <code>ItemExistsException</code> and no changes are made.
-     * <p/>
-     * If successful, the change is persisted immediately, there is no need to call <code>save</code>.
-     * <p/>
-     * The <code>destAbsPath</code> provided must not have an index on its final
-     * element. If it does then a <code>RepositoryException</code> is thrown.
-     * Strictly speaking, the <code>destAbsPath</code> parameter is actually an
-     * <i>absolute path</i> to the parent node of the new location, appended
-     * with the new <i>name</i> desired for the cloned node. It does not specify
-     * a position within the child node ordering. If ordering is supported by
-     * the node type of the parent node of the new location, then the new clone
-     * of the node is appended to the end of the child node list. The resulting
-     * position within a same-name sibling set can, however, be determined from
-     * the path returned by this method, which will include an index, if one is
-     * required.
-     * <p/>
-     * 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).
-     * <p/>
-     * A <code>NoSuchWorkspaceException</code> is thrown if <code>srcWorkspace</code> does not
-     * exist or if the current <code>Session</code> does not have permission to access it.
-     * <p/>
-     * A <code>ConstraintViolationException</code> is thrown if the operation would violate a node-type
-     * or other implementation-specific constraint or if <code>srcWorkspace</code> is the name of this workspace.
-     * In other words, if an attempt is made to clone a subtree into the same workspace.
-     * <p/>
-     * A <code>VersionException</code> is thrown if the parent node of <code>destAbsPath</code> is
-     * versionable and checked-in, or is non-versionable but its nearest versionable ancestor is
-     * checked-in. This exception will also be thrown if <code>removeExisting</code> is <code>true</code>,
-     * and an identifier conflict occurs that would require the moving and/or altering of a node that is checked-in.
-     * <p/>
-     * An <code>AccessDeniedException</code> is thrown if the current session (i.e. the session that
-     * was used to acquire this <code>Workspace</code> object) does not have sufficient access rights
-     * to complete the operation.
-     * <p/>
-     * A <code>PathNotFoundException</code> is thrown if the node at <code>srcAbsPath</code> in
-     * <code>srcWorkspace</code> or the parent of <code>destAbsPath</code> in this workspace does not exist.
-     * <p/>
-     * An <code>ItemExistsException</code> is thrown if a node or property already exists at
-     * <code>destAbsPath</code>
-     * <p/>
-     * An <code>ItemExistException</code> is thrown if a node already exists at
-     * <code>destAbsPath</code> and same-name siblings are not allowed or if
-     * <code>removeExisting</code> is <code>false</code> and an identifier conflict occurs.
-     * <p/>
-     * Note that if a property already exists at <code>destAbsPath</code>, the
-     * operation succeeds, since a node may have a child node and property with
-     * the same name.
-     * <p/>
-     * A <code>LockException</code> 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 <code>srcWorkspace</code>.
-     * @param destAbsPath the location to which the node at <code>srcAbsPath</code>
-     * is to be copied in <code>this</code> workspace.
-     * @param removeExisting if <code>false</code> then this method throws an
-     * <code>ItemExistsException</code> on identifier conflict with an incoming node.
-     * If <code>true</code> then a identifier conflict is resolved by removing the existing node
-     * from its location in this workspace and cloning (copying in) the one from
-     * <code>srcWorkspace</code>.
-     * @return the path of the node at its new position.
-     * @throws NoSuchWorkspaceException if <code>destWorkspace</code> 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 <code>destAbsPath</code> is
-     * versionable and checked-in, or is non-versionable but its nearest versionable ancestor is
-     * checked-in. This exception will also be thrown if <code>removeExisting</code> is <code>true</code>,
-     * and an identifier conflict occurs that would require the moving and/or altering of a node that is checked-in.
-     * @throws AccessDeniedException if the current session does not have
-     * sufficient access rights to complete the operation.
-     * @throws PathNotFoundException if the node at <code>srcAbsPath</code> in
-     * <code>srcWorkspace</code> or the parent of <code>destAbsPath</code> in this workspace does not exist.
-     * @throws ItemExistsException if a node already exists at
-     * <code>destAbsPath</code> and same-name siblings are not allowed or if
-     * <code>removeExisting</code> is <code>false</code> and an identifier conflict occurs.
-     * @throws LockException if a lock prevents the clone.
-     * @throws RepositoryException if the last element of <code>destAbsPath</code>
-     * has an index or if another error occurs.
-     */
-    public String clone283(String srcWorkspace, String srcAbsPath,
-                           String destAbsPath, boolean removeExisting)
-            throws NoSuchWorkspaceException, ConstraintViolationException,
-            VersionException, AccessDeniedException, PathNotFoundException,
-            ItemExistsException, LockException, RepositoryException {
-
-        // check state of this instance
-        sanityCheck();
-
-        // check workspace name
-        if (getName().equals(srcWorkspace)) {
-            // clone to same workspace is allowed for mix:shareable nodes,
-            // but only if removeExisting is false
-            if (!removeExisting) {
-                return internalClone(srcAbsPath, destAbsPath);
-            }
-            // same as current workspace
-            String msg = srcWorkspace + ": illegal workspace (same as current)";
-            log.debug(msg);
-            throw new RepositoryException(msg);
-        }
-
-        // check authorization for specified workspace
-        if (!session.getAccessManager().canAccess(srcWorkspace)) {
-            throw new AccessDeniedException("not authorized to access " + srcWorkspace);
-        }
-
-        // clone (i.e. pull) subtree at srcAbsPath from srcWorkspace
-        // to 'this' workspace at destAbsPath
-
-        SessionImpl srcSession = null;
-        try {
-            // create session on other workspace for current subject
-            // (may throw NoSuchWorkspaceException and AccessDeniedException)
-            srcSession = rep.createSession(session.getSubject(), srcWorkspace);
-            WorkspaceImpl srcWsp = (WorkspaceImpl) srcSession.getWorkspace();
-
-            // do cross-workspace copy
-            int mode = BatchedItemOperations.CLONE;
-            if (removeExisting) {
-                mode = BatchedItemOperations.CLONE_REMOVE_EXISTING;
-            }
-            return internalCopy(srcAbsPath, srcWsp, destAbsPath, mode);
-        } finally {
-            if (srcSession != null) {
-                // we don't need the other session anymore, logout
-                srcSession.logout();
-            }
-        }
-    }
-
-    /**
-     * Moves the node at <code>srcAbsPath</code> (and its entire subtree) to the
-     * new location at <code>destAbsPath</code>. Returns the path of the node at
-     * its new position. Note that the returned path will indicate the resulting
-     * same-name sibling index of the destination, if necessary, unlike the
-     * supplied <code>destAbsPath</code> parameter (see below).
-     * <p/>
-     * If successful,
-     * the change is persisted immediately, there is no need to call <code>save</code>.
-     * Note that this is in contrast to {@link Session#move} which operates within the
-     * transient space and hence requires a <code>save</code>.
-     * <p/>
-     * The identifiers of referenceable nodes must not be changed by a <code>move</code>.
-     * The identifiers of non-referenceable nodes <i>may</i> change.
-     * <p/>
-     * The <code>destAbsPath</code> provided must not
-     * have an index on its final element. If it does then a <code>RepositoryException</code>
-     * is thrown. Strictly speaking, the <code>destAbsPath</code> parameter is actually an <i>absolute path</i>
-     * to the parent node of the new location, appended with the new <i>name</i> desired for the
-     * moved node. It does not specify a position within the child node
-     * ordering. If ordering is supported by the node type of
-     * the parent node of the new location, then the newly moved node is appended to the end of the
-     * child node list. The resulting position within a same-name sibling set can,
-     * however, be determined from the path returned by this method,
-     * which will include an index if one is required.
-     * <p/>
-     * 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).
-     * <p/>
-     * The identifiers of referenceable nodes must not be changed by a <code>move</code>.
-     * The identifiers of non-referenceable nodes may change.
-     * <p/>
-     * A <code>ConstraintViolationException</code> is thrown if the operation would violate a node-type
-     * or other implementation-specific constraint.
-     * <p/>
-     * A <code>VersionException</code> is thrown if the parent node of <code>destAbsPath</code>
-     * or the parent node of <code>srcAbsPath</code> is versionable and checked-in, or is
-     * non-versionable but its nearest versionable ancestor is checked-in.
-     * <p/>
-     * An <code>AccessDeniedException</code> is thrown if the current session (i.e. the session that
-     * was used to acquire this <code>Workspace</code> object) does not have sufficient access rights
-     * to complete the operation.
-     * <p/>
-     * A <code>PathNotFoundException</code> is thrown if the node at <code>srcAbsPath</code> or the
-     * parent of <code>destAbsPath</code> does not exist.
-     * <p/>
-     * An <code>ItemExistException</code> is thrown if a node already exists at
-     * <code>destAbsPath</code> and same-name siblings are not allowed.
-     * <p/>
-     * Note that if a property already exists at <code>destAbsPath</code>, the
-     * operation succeeds, since a node may have a child node and property with
-     * the same name
-     * <p/>
-     * A <code>LockException</code> 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 <code>srcAbsPath</code>
-     * is to be moved.
-     * @return the path of the node at its new position.
-     * @throws ConstraintViolationException if the operation would violate a
-     * node-type or other implementation-specific constraint
-     * @throws VersionException if the parent node of <code>destAbsPath</code>
-     * or the parent node of <code>srcAbsPath</code> 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 acquire this <code>Workspace</code> object) does not have
-     * sufficient access rights to complete the operation.
-     * @throws PathNotFoundException if the node at <code>srcAbsPath</code> or
-     * the parent of <code>destAbsPath</code> does not exist.
-     * @throws ItemExistsException if a node already exists at
-     * <code>destAbsPath</code> and same-name siblings are not allowed.
-     * @throws LockException if a lock prevents the move.
-     * @throws RepositoryException if the last element of <code>destAbsPath</code>
-     *         has an index or if another error occurs.
-     */
-    public String move283(String srcAbsPath, String destAbsPath)
-            throws ConstraintViolationException, VersionException,
-            AccessDeniedException, PathNotFoundException, ItemExistsException,
-            LockException, RepositoryException {
-
-        // check state of this instance
-        sanityCheck();
-
-        // intra-workspace move...
-
-        Path srcPath;
-        try {
-            srcPath = session.getQPath(srcAbsPath).getNormalizedPath();
-        } catch (NameException e) {
-            String msg = "invalid path: " + srcAbsPath;
-            log.debug(msg);
-            throw new RepositoryException(msg, e);
-        }
-        if (!srcPath.isAbsolute()) {
-            throw new RepositoryException("not an absolute path: " + srcAbsPath);
-        }
-
-        Path destPath;
-        try {
-            destPath = session.getQPath(destAbsPath).getNormalizedPath();
-        } catch (NameException e) {
-            String msg = "invalid path: " + destAbsPath;
-            log.debug(msg);
-            throw new RepositoryException(msg, e);
-        }
-        if (!destPath.isAbsolute()) {
-            throw new RepositoryException("not an absolute path: " + destAbsPath);
-        }
-
-        BatchedItemOperations ops = new BatchedItemOperations(
-                stateMgr, rep.getNodeTypeRegistry(), session.getLockManager(),
-                session, hierMgr);
-
-        try {
-            ops.edit();
-        } catch (IllegalStateException e) {
-            String msg = "unable to start edit operation";
-            log.debug(msg);
-            throw new RepositoryException(msg, e);
-        }
-
-        boolean succeeded = false;
-
-        try {
-            NodeId id = ops.move(srcPath, destPath);
-            ops.update();
-            succeeded = true;
-            return session.getJCRPath(hierMgr.getPath(id));
-        } finally {
-            if (!succeeded) {
-                // update operation failed, cancel all modifications
-                ops.cancel();
-            }
-        }
-    }
-
     //------------------------------------------< EventStateCollectionFactory >
     /**
      * {@inheritDoc}



Mime
View raw message