clientnode.java

来自「jsr170接口的java实现。是个apache的开源项目。」· Java 代码 · 共 636 行 · 第 1/2 页

        try {
            return remote.hasProperty(path);
        } catch (RemoteException ex) {
            throw new RemoteRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public boolean hasNodes() throws RepositoryException {
        try {
            return remote.hasNodes();
        } catch (RemoteException ex) {
            throw new RemoteRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public boolean hasProperties() throws RepositoryException {
        try {
            return remote.hasProperties();
        } catch (RemoteException ex) {
            throw new RemoteRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public NodeType getPrimaryNodeType() throws RepositoryException {
        try {
            return getFactory().getNodeType(remote.getPrimaryNodeType());
        } catch (RemoteException ex) {
            throw new RemoteRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public NodeType[] getMixinNodeTypes() throws RepositoryException {
        try {
            return getNodeTypeArray(remote.getMixinNodeTypes());
        } catch (RemoteException ex) {
            throw new RemoteRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public boolean isNodeType(String type) throws RepositoryException {
        try {
            return remote.isNodeType(type);
        } catch (RemoteException ex) {
            throw new RemoteRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public void addMixin(String name) throws RepositoryException {
        try {
            remote.addMixin(name);
        } catch (RemoteException ex) {
            throw new RemoteRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public void removeMixin(String name) throws RepositoryException {
        try {
            remote.removeMixin(name);
        } catch (RemoteException ex) {
            throw new RemoteRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public boolean canAddMixin(String name) throws RepositoryException {
        try {
            return remote.canAddMixin(name);
        } catch (RemoteException ex) {
            throw new RemoteRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public NodeDefinition getDefinition() throws RepositoryException {
        try {
            return getFactory().getNodeDef(remote.getDefinition());
        } catch (RemoteException ex) {
            throw new RemoteRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public Version checkin() throws RepositoryException {
        try {
            return getFactory().getVersion(getSession(), remote.checkin());
        } catch (RemoteException ex) {
            throw new RemoteRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public void checkout() throws RepositoryException {
        try {
            remote.checkout();
        } catch (RemoteException ex) {
            throw new RemoteRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public void update(String workspace) throws RepositoryException {
        try {
            remote.update(workspace);
        } catch (RemoteException ex) {
            throw new RemoteRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public NodeIterator merge(String workspace, boolean bestEffort)
            throws RepositoryException {
        try {
            return getFactory().getNodeIterator(getSession(), remote.merge(workspace, bestEffort));
        } catch (RemoteException ex) {
            throw new RemoteRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public void cancelMerge(Version version) throws RepositoryException {
        try {
            remote.cancelMerge(version.getUUID());
        } catch (RemoteException ex) {
            throw new RemoteRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public void doneMerge(Version version) throws RepositoryException {
        try {
            remote.doneMerge(version.getUUID());
        } catch (RemoteException ex) {
            throw new RemoteRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public String getCorrespondingNodePath(String workspace)
            throws RepositoryException {
        try {
            return remote.getCorrespondingNodePath(workspace);
        } catch (RemoteException ex) {
            throw new RemoteRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public int getIndex() throws RepositoryException {
        try {
            return remote.getIndex();
        } catch (RemoteException ex) {
            throw new RemoteRepositoryException(ex);
        }
    }

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

    /** {@inheritDoc} */
    public void restore(Version version, boolean removeExisting)
            throws RepositoryException {
        try {
            remote.restoreByUUID(version.getUUID(), removeExisting);
        } catch (RemoteException ex) {
            throw new RemoteRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public void restore(Version version, String path, boolean removeExisting)
            throws RepositoryException {
        try {
            remote.restore(version.getUUID(), path, removeExisting);
        } catch (RemoteException ex) {
            throw new RemoteRepositoryException(ex);
        }
    }

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

    /** {@inheritDoc} */
    public Property setProperty(String name, String[] strings, int type)
            throws RepositoryException {
        Value[] values = new Value[strings.length];
        for (int i = 0; i < strings.length; i++) {
            values[i] = getSession().getValueFactory().createValue(strings[i]);
        }
        return setProperty(name, values, type);
    }

    /** {@inheritDoc} */
    public Property setProperty(String name, Value[] values, int type)
            throws RepositoryException {
        try {
            Value[] serials = SerialValueFactory.makeSerialValueArray(values);
            RemoteProperty property = remote.setProperty(name, serials, type);
            return getFactory().getProperty(getSession(), property);
        } catch (RemoteException ex) {
            throw new RemoteRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public Property setProperty(String name, Value value, int type)
            throws RepositoryException {
        try {
            RemoteProperty property =
                    remote.setProperty(name, SerialValueFactory.makeSerialValue(value), type);
            return getFactory().getProperty(getSession(), property);
        } catch (RemoteException ex) {
            throw new RemoteRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public Property setProperty(String name, String value, int type)
            throws RepositoryException {
        return setProperty(name, getSession().getValueFactory().createValue(value), type);
    }

    /** {@inheritDoc} */
    public boolean isCheckedOut() throws RepositoryException {
        try {
            return remote.isCheckedOut();
        } catch (RemoteException ex) {
            throw new RemoteRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public VersionHistory getVersionHistory() throws RepositoryException {
        try {
            return getFactory().getVersionHistory(getSession(), remote.getVersionHistory());
        } catch (RemoteException ex) {
            throw new RemoteRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public Version getBaseVersion() throws RepositoryException {
        try {
            return getFactory().getVersion(getSession(), remote.getBaseVersion());
        } catch (RemoteException ex) {
            throw new RemoteRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public Lock lock(boolean isDeep, boolean isSessionScoped)
            throws RepositoryException {
        try {
            RemoteLock lock = remote.lock(isDeep, isSessionScoped);
            return getFactory().getLock(this, lock);
        } catch (RemoteException ex) {
            throw new RemoteRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public Lock getLock() throws RepositoryException {
        try {
            return getFactory().getLock(this, remote.getLock());
        } catch (RemoteException ex) {
            throw new RemoteRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public void unlock() throws RepositoryException {
        try {
            remote.unlock();
        } catch (RemoteException ex) {
            throw new RemoteRepositoryException(ex);
        }
    }

    /** {@inheritDoc} */
    public boolean holdsLock() throws RepositoryException {
        try {
            return remote.holdsLock();
        } catch (RemoteException ex) {
            throw new RemoteRepositoryException(ex);
        }
     }

    /** {@inheritDoc} */
    public boolean isLocked() throws RepositoryException {
        try {
            return remote.isLocked();
        } catch (RemoteException ex) {
            throw new RemoteRepositoryException(ex);
        }
    }

}