servernode.java

jsr170接口的java实现。是个apache的开源项目。

        }
    }

    /** {@inheritDoc} */
    public void removeMixin(String name)
            throws RepositoryException, RemoteException {
        try {
            node.removeMixin(name);
        } catch (RepositoryException ex) {
            throw getRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public void orderBefore(String src, String dst)
            throws RepositoryException, RemoteException {
        try {
            node.orderBefore(src, dst);
        } catch (RepositoryException ex) {
            throw getRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public RemoteProperty setProperty(String name, Value[] values)
            throws RepositoryException, RemoteException {
        try {
            Property property = node.setProperty(name, values);
            if (property == null) {
                return null;
            } else {
                return getFactory().getRemoteProperty(property);
            }
        } catch (RepositoryException ex) {
            throw getRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public RemoteNodeDefinition getDefinition()
            throws RepositoryException, RemoteException {
        try {
            return getFactory().getRemoteNodeDefinition(node.getDefinition());
        } catch (RepositoryException ex) {
            throw getRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public RemoteVersion checkin() throws RepositoryException, RemoteException {
        try {
            return getFactory().getRemoteVersion(node.checkin());
        } catch (RepositoryException ex) {
            throw getRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public void checkout() throws RepositoryException, RemoteException {
        try {
            node.checkout();
        } catch (RepositoryException ex) {
            throw getRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public String getCorrespondingNodePath(String workspace)
            throws RepositoryException, RemoteException {
        try {
            return node.getCorrespondingNodePath(workspace);
        } catch (RepositoryException ex) {
            throw getRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public int getIndex() throws RepositoryException, RemoteException {
        try {
            return node.getIndex();
        } catch (RepositoryException ex) {
            throw getRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public RemoteIterator merge(String workspace, boolean bestEffort)
            throws RepositoryException, RemoteException {
        try {
            return getFactory().getRemoteNodeIterator(node.merge(workspace, bestEffort));
        } catch (RepositoryException ex) {
            throw getRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public void cancelMerge(String versionUUID)
            throws RepositoryException, RemoteException {
        try {
            node.cancelMerge(getVersionByUUID(versionUUID));
        } catch (RepositoryException ex) {
            throw getRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public void doneMerge(String versionUUID)
            throws RepositoryException, RemoteException {
        try {
            node.doneMerge(getVersionByUUID(versionUUID));
        } catch (RepositoryException ex) {
            throw getRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public void restore(String version, boolean removeExisting)
            throws RepositoryException, RemoteException {
        try {
            node.restore(version, removeExisting);
        } catch (RepositoryException ex) {
            throw getRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public void restoreByUUID(String versionUUID, boolean removeExisting)
            throws RepositoryException, RemoteException {
        try {
            node.restore(getVersionByUUID(versionUUID), removeExisting);
        } catch (RepositoryException ex) {
            throw getRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public void restore(String versionUUID, String path, boolean removeExisting)
            throws RepositoryException, RemoteException {
        try {
            node.restore(getVersionByUUID(versionUUID), path, removeExisting);
        } catch (RepositoryException ex) {
            throw getRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public void restoreByLabel(String label, boolean removeExisting)
            throws RepositoryException, RemoteException {
        try {
            node.restoreByLabel(label, removeExisting);
        } catch (RepositoryException ex) {
            throw getRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public void update(String workspace)
            throws RepositoryException, RemoteException {
        try {
            node.update(workspace);
        } catch (RepositoryException ex) {
            throw getRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public boolean holdsLock() throws RepositoryException, RemoteException {
        try {
            return node.holdsLock();
        } catch (RepositoryException ex) {
            throw getRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public boolean isCheckedOut() throws RepositoryException, RemoteException {
        try {
            return node.isCheckedOut();
        } catch (RepositoryException ex) {
            throw getRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public RemoteVersionHistory getVersionHistory()
            throws RepositoryException, RemoteException {
        try {
            return getFactory().getRemoteVersionHistory(node.getVersionHistory());
        } catch (RepositoryException ex) {
            throw getRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public RemoteVersion getBaseVersion()
            throws RepositoryException, RemoteException {
        try {
            return getFactory().getRemoteVersion(node.getBaseVersion());
        } catch (RepositoryException ex) {
            throw getRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public boolean isLocked() throws RepositoryException, RemoteException {
        try {
            return node.isLocked();
        } catch (RepositoryException ex) {
            throw getRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public RemoteProperty setProperty(String name, Value[] values, int type)
            throws RepositoryException, RemoteException {
        try {
            Property property = node.setProperty(name, values, type);
            return getFactory().getRemoteProperty(property);
        } catch (RepositoryException ex) {
            throw getRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public void unlock() throws RepositoryException, RemoteException {
        try {
            node.unlock();
        } catch (RepositoryException ex) {
            throw getRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public RemoteLock getLock() throws RepositoryException, RemoteException {
        try {
            return getFactory().getRemoteLock(node.getLock());
        } catch (RepositoryException ex) {
            throw getRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public RemoteLock lock(boolean isDeep, boolean isSessionScoped)
            throws RepositoryException, RemoteException {
        try {
            Lock lock = node.lock(isDeep, isSessionScoped);
            return getFactory().getRemoteLock(lock);
        } catch (RepositoryException ex) {
            throw getRepositoryException(ex);
        }
    }

    //---------- Implementation helper -----------------------------------------

    /**
     * Returns the {@link Version} instance for the given UUID.
     *
     * @param versionUUID The UUID of the version.
     *
     * @return The version node.
     *
     * @throws RepositoryException if an error occurrs accessing the version
     *      node or if the UUID does not denote a version.
     */
    protected Version getVersionByUUID(String versionUUID)
            throws RepositoryException {

        // get the version node by its UUID from the version history's session
        Session session = node.getSession();
        Node versionNode = session.getNodeByUUID(versionUUID);

        // check whether the node is a session, which it should be according
        // to the spec (methods returning nodes should automatically return
        // the correct type).
        if (versionNode instanceof Version) {
            return (Version) versionNode;
        }

        // otherwise fail
        throw new RepositoryException("Cannot find version " + versionUUID);
    }
}