| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package org.apache.jackrabbit.commons; |
| |
| import java.io.InputStream; |
| import java.util.Calendar; |
| |
| import javax.jcr.Item; |
| import javax.jcr.ItemNotFoundException; |
| import javax.jcr.ItemVisitor; |
| import javax.jcr.Node; |
| import javax.jcr.PathNotFoundException; |
| import javax.jcr.Property; |
| import javax.jcr.PropertyIterator; |
| import javax.jcr.RepositoryException; |
| import javax.jcr.Session; |
| import javax.jcr.UnsupportedRepositoryOperationException; |
| import javax.jcr.Value; |
| import javax.jcr.ValueFactory; |
| import javax.jcr.lock.LockException; |
| import javax.jcr.nodetype.NodeType; |
| import javax.jcr.nodetype.NodeTypeManager; |
| import javax.jcr.version.Version; |
| import javax.jcr.version.VersionHistory; |
| |
| /** |
| * Abstract base class for implementing the JCR {@link Node} interface. |
| * <p> |
| * {@link Item} methods <em>without</em> a default implementation: |
| * <ul> |
| * <li>{@link Item#accept(javax.jcr.ItemVisitor)}</li> |
| * <li>{@link Item#getName()}</li> |
| * <li>{@link Item#getParent()}</li> |
| * <li>{@link Item#getSession()}</li> |
| * <li>{@link Item#isModified()}</li> |
| * <li>{@link Item#isNew()}</li> |
| * <li>{@link Item#isSame(Item)}</li> |
| * <li>{@link Item#refresh(boolean)}</li> |
| * <li>{@link Item#remove()}</li> |
| * <li>{@link Item#save()}</li> |
| * </ul> |
| * <p> |
| * {@link Node} methods <em>without</em> a default implementation: |
| * <ul> |
| * <li>{@link Node#addMixin(String)}</li> |
| * <li>{@link Node#addNode(String)}</li> |
| * <li>{@link Node#addNode(String, String)}</li> |
| * <li>{@link Node#canAddMixin(String)}</li> |
| * <li>{@link Node#cancelMerge(Version)}</li> |
| * <li>{@link Node#checkin()}</li> |
| * <li>{@link Node#checkout()}</li> |
| * <li>{@link Node#doneMerge(Version)}</li> |
| * <li>{@link Node#getBaseVersion()}</li> |
| * <li>{@link Node#getCorrespondingNodePath(String)}</li> |
| * <li>{@link Node#getDefinition()}</li> |
| * <li>{@link Node#getIndex()}</li> |
| * <li>{@link Node#getLock()}</li> |
| * <li>{@link Node#getNode(String)}</li> |
| * <li>{@link Node#getNodes()}</li> |
| * <li>{@link Node#getNodes(String)}</li> |
| * <li>{@link Node#getPrimaryItem()}</li> |
| * <li>{@link Node#getProperties()}</li> |
| * <li>{@link Node#getProperties(String)}</li> |
| * <li>{@link Node#getReferences()}</li> |
| * <li>{@link Node#lock(boolean, boolean)}</li> |
| * <li>{@link Node#merge(String, boolean)}</li> |
| * <li>{@link Node#orderBefore(String, String)}</li> |
| * <li>{@link Node#removeMixin(String)}</li> |
| * <li>{@link Node#restore(Version, String, boolean)}</li> |
| * <li>{@link Node#setProperty(String, Value)}</li> |
| * <li>{@link Node#setProperty(String, Value[])}</li> |
| * <li>{@link Node#unlock()}</li> |
| * <li>{@link Node#update(String)}</li> |
| * </ul> |
| */ |
| public abstract class AbstractNode extends AbstractItem implements Node { |
| |
| //----------------------------------------------------------------< Item > |
| |
| /** |
| * Accepts the given item visitor. |
| * <p> |
| * The default implementation calls {@link ItemVisitor#visit(Node)} on |
| * the given visitor with this node as the argument. |
| * |
| * @param visitor item visitor |
| * @throws RepositoryException if an error occurs |
| */ |
| public void accept(ItemVisitor visitor) throws RepositoryException { |
| visitor.visit(this); |
| } |
| |
| /** |
| * Returns the path of this node. |
| * <p> |
| * The default implementation recursively calls this method on the |
| * parent node and appends the name and optionally the index of this |
| * node to construct the full path. Returns "/" if the parent node is |
| * not available (i.e. this is the root node). |
| * |
| * @return node path |
| * @throws RepositoryException if an error occurs |
| */ |
| public String getPath() throws RepositoryException { |
| try { |
| StringBuffer buffer = new StringBuffer(getParent().getPath()); |
| if (buffer.length() > 1) { |
| buffer.append('/'); |
| } |
| buffer.append(getName()); |
| int index = getIndex(); |
| if (index != 1) { |
| buffer.append('['); |
| buffer.append(index); |
| buffer.append(']'); |
| } |
| return buffer.toString(); |
| } catch (ItemNotFoundException e) { |
| return "/"; |
| } |
| } |
| |
| /** |
| * Returns <code>true</code>. |
| * |
| * @return <code>true</code> |
| */ |
| public boolean isNode() { |
| return true; |
| } |
| |
| //----------------------------------------------------------------< Node > |
| |
| /** |
| * Returns the declared mixin node types of this node. |
| * <p> |
| * The default implementation uses the values of the |
| * <code>jcr:mixinTypes</code> property to look up the mixin node types |
| * from the {@link NodeTypeManager} of the current workspace. |
| * |
| * @return mixin node types |
| * @throws RepositoryException if an error occurs |
| */ |
| public NodeType[] getMixinNodeTypes() throws RepositoryException { |
| try { |
| NodeTypeManager manager = |
| getSession().getWorkspace().getNodeTypeManager(); |
| Property property = getProperty(getName("jcr:mixinTypes")); |
| Value[] values = property.getValues(); |
| NodeType[] types = new NodeType[values.length]; |
| for (int i = 0; i < values.length; i++) { |
| types[i] = manager.getNodeType(values[i].getString()); |
| } |
| return types; |
| } catch (PathNotFoundException e) { |
| // jcr:mixinTypes does not exist, i.e. no mixin types on this node |
| return new NodeType[0]; |
| } |
| } |
| |
| /** |
| * Returns the primary node type of this node. |
| * <p> |
| * The default implementation uses the value of the |
| * <code>jcr:primaryType</code> property to look up the primary |
| * node type from the {@link NodeTypeManager} of the current workspace. |
| * |
| * @return primary node type |
| * @throws RepositoryException if an error occurs |
| */ |
| public NodeType getPrimaryNodeType() throws RepositoryException { |
| NodeTypeManager manager = |
| getSession().getWorkspace().getNodeTypeManager(); |
| Property property = getProperty(getName("jcr:primaryType")); |
| return manager.getNodeType(property.getString()); |
| } |
| |
| /** |
| * Returns the property at the given relative path from this node. |
| * <p> |
| * The default implementation looks up the parent node of the given |
| * relative path and iterates through the properties of that node to |
| * find and return the identified property. |
| * |
| * @param relPath relative path of the property |
| * @return property |
| * @throws PathNotFoundException if the property is not found |
| * @throws RepositoryException if an error occurs |
| */ |
| public Property getProperty(String relPath) |
| throws PathNotFoundException, RepositoryException { |
| // Corner case, remove any "/." self references at the end of the path |
| while (relPath.endsWith("/.")) { |
| relPath = relPath.substring(0, relPath.length() - 2); |
| } |
| |
| // Find the parent node of the identified property |
| Node node = this; |
| int slash = relPath.lastIndexOf('/'); |
| if (slash == 0) { |
| node = getSession().getRootNode(); |
| relPath = relPath.substring(1); |
| } else if (slash > 0) { |
| node = getNode(relPath.substring(0, slash)); |
| relPath = relPath.substring(slash + 1); |
| } |
| |
| // Look for the named property. Must iterate and re-check for the name |
| // since the client could have used an invalid path like "./a|b". |
| PropertyIterator properties = node.getProperties(relPath); |
| while (properties.hasNext()) { |
| Property property = (Property) properties.next(); |
| if (relPath.equals(property.getName())) { |
| return property; |
| } |
| } |
| |
| throw new PathNotFoundException("Property not found: " + relPath); |
| } |
| |
| /** |
| * Returns the UUID of this node. |
| * <p> |
| * The default implementation checks if this node is referenceable (i.e. of |
| * type <code>mix:referenceable</code>) and returns the contents of the |
| * <code>jcr:uuid</code> property if it is. |
| * |
| * @return node UUID |
| * @throws UnsupportedRepositoryOperationException |
| * if this node is not referenceable |
| * @throws RepositoryException if an error occurs |
| */ |
| public String getUUID() |
| throws UnsupportedRepositoryOperationException, RepositoryException { |
| if (isNodeType(getName("mix:referenceable"))) { |
| return getProperty(getName("jcr:uuid")).getString(); |
| } else { |
| throw new UnsupportedRepositoryOperationException( |
| "This node is not referenceable: " + getPath()); |
| } |
| } |
| |
| /** |
| * Returns the version history of this node. |
| * <p> |
| * The default implementation returns the containing version history of |
| * the base version of this node. |
| * |
| * @return version history |
| * @throws RepositoryException if an error occurs |
| */ |
| public VersionHistory getVersionHistory() throws RepositoryException { |
| return getBaseVersion().getContainingHistory(); |
| } |
| |
| /** |
| * Checks whether a node at the given relative path exists. |
| * <p> |
| * The default implementation looks up the node using |
| * {@link Node#getNode(String)} and returns <code>true</code> if |
| * a {@link PathNotFoundException} is not thrown. |
| * |
| * @param relPath relative path |
| * @return <code>true</code> if a node exists at the given path, |
| * <code>false</code> otherwise |
| * @throws RepositoryException if an error occurs |
| */ |
| public boolean hasNode(String relPath) throws RepositoryException { |
| try { |
| getNode(relPath); |
| return true; |
| } catch (PathNotFoundException e) { |
| return false; |
| } |
| } |
| |
| /** |
| * Checks if this node has one or more properties. |
| * <p> |
| * The default implementation calls {@link Node#getNodes()} and returns |
| * <code>true</code> iff returned iterator has at least one element. |
| * |
| * @return <code>true</code> if this node has child nodes, |
| * <code>false</code> otherwise |
| * @throws RepositoryException if an error occurs |
| */ |
| public boolean hasNodes() throws RepositoryException { |
| return getNodes().hasNext(); |
| } |
| |
| /** |
| * Checks if this node has one or more properties. |
| * <p> |
| * The default implementation calls {@link Node#getProperties()} and |
| * returns <code>true</code> iff returned iterator has at least one element. |
| * <p> |
| * Note that in normal circumstances (i.e. no weird access controls) this |
| * method will always return <code>true</code> since all nodes always have |
| * at least the <code>jcr:primaryType</code> property. |
| * |
| * @return <code>true</code> if this node has properties, |
| * <code>false</code> otherwise |
| * @throws RepositoryException if an error occurs |
| */ |
| public boolean hasProperties() throws RepositoryException { |
| return getProperties().hasNext(); |
| } |
| |
| /** |
| * Checks whether a property at the given relative path exists. |
| * <p> |
| * The default implementation looks up the property using |
| * {@link Node#getProperty(String)} and returns <code>true</code> if |
| * a {@link PathNotFoundException} is not thrown. |
| * |
| * @param relPath relative path |
| * @return <code>true</code> if a property exists at the given path, |
| * <code>false</code> otherwise |
| * @throws RepositoryException if an error occurs |
| */ |
| public boolean hasProperty(String relPath) throws RepositoryException { |
| try { |
| getProperty(relPath); |
| return true; |
| } catch (PathNotFoundException e) { |
| return false; |
| } |
| } |
| |
| /** |
| * Checks if this node holds a lock. |
| * <p> |
| * The default implementation calls {@link Node#getLock()} and returns |
| * <code>true</code> iff the holding node of the lock is the same as this |
| * node. |
| * |
| * @return <code>true</code> if this node holds a lock, |
| * <code>false</code> otherwise |
| * @throws RepositoryException if an error occurs |
| */ |
| public boolean holdsLock() throws RepositoryException { |
| try { |
| return isSame(getLock().getNode()); |
| } catch (LockException e) { |
| return false; |
| } |
| } |
| |
| /** |
| * Checks whether this node is checked out. |
| * <p> |
| * The default implementation checks the <code>jcr:isCheckedOut</code> |
| * property if this node is versionable, and recursively calls this method |
| * on the parent node if this node is not versionable. A non-versionable |
| * root node always returns <code>true</code> from this method. |
| * |
| * @return <code>true</code> if this node is checked out, |
| * <code>false</code> otherwise |
| * @throws RepositoryException if an error occurs |
| */ |
| public boolean isCheckedOut() throws RepositoryException { |
| if (isNodeType(getName("jcr:versionable"))) { |
| // This node is versionable, check the jcr:isCheckedOut property |
| return getProperty(getName("jcr:isCheckedOut")).getBoolean(); |
| } else { |
| try { |
| // This node is not versionable, is the parent checked out? |
| return getParent().isCheckedOut(); |
| } catch (ItemNotFoundException e) { |
| // This node is the root node, always checked out |
| return true; |
| } |
| } |
| } |
| |
| /** |
| * Checks if this node is locked. |
| * <p> |
| * The default implementation calls {@link Node#getLock()} and returns |
| * <code>true</code> iff a {@link LockException} is not thrown. |
| * |
| * @return <code>true</code> if this node is locked, |
| * <code>false</code> otherwise |
| * @throws RepositoryException if an error occurs |
| */ |
| public boolean isLocked() throws RepositoryException { |
| try { |
| getLock(); |
| return true; |
| } catch (LockException e) { |
| return false; |
| } |
| } |
| |
| /** |
| * Checks whether this node is of the given type. |
| * <p> |
| * The default implementation iterates through the primary and mixin |
| * types and all the supertypes of this node, returning <code>true</code> |
| * if a type with the given name is encountered. Returns <code>false</code> |
| * if none of the types matches. |
| * |
| * @param name type name |
| * @return <code>true</code> if this node is of the given type, |
| * <code>false</code> otherwise |
| * @throws RepositoryException if an error occurs |
| */ |
| public boolean isNodeType(String name) throws RepositoryException { |
| NodeType type = getPrimaryNodeType(); |
| if (name.equals(type.getName())) { |
| return true; |
| } |
| NodeType[] supertypes = type.getSupertypes(); |
| for (int i = 0; i < supertypes.length; i++) { |
| if (name.equals(supertypes[i].getName())) { |
| return true; |
| } |
| } |
| |
| NodeType[] mixins = getMixinNodeTypes(); |
| for (int i = 0; i < mixins.length; i++) { |
| if (name.equals(mixins[i].getName())) { |
| return true; |
| } |
| supertypes = mixins[i].getSupertypes(); |
| for (int j = 0; j < supertypes.length; j++) { |
| if (name.equals(supertypes[j].getName())) { |
| return true; |
| } |
| } |
| } |
| |
| return false; |
| } |
| |
| /** |
| * Restores this node to the version with the given name. |
| * <p> |
| * The default implement retrieves the named {@link Version} from the |
| * associated {@link VersionHistory} and forwards the call to the |
| * {@link Node#restore(Version, boolean)} method. |
| * |
| * @param versionName version name |
| * @param removeExisting passed through |
| * @throws RepositoryException if an error occurs |
| */ |
| public void restore(String versionName, boolean removeExisting) |
| throws RepositoryException { |
| restore(getVersionHistory().getVersion(versionName), removeExisting); |
| } |
| |
| /** |
| * Restores this node to the given version. |
| * <p> |
| * The default implementation forwards the call to the |
| * {@link Node#restore(Version, String, boolean)} method using the |
| * relative path ".". |
| * |
| * @param version passed through |
| * @param removeExisting passed through |
| * @throws RepositoryException if an error occurs |
| */ |
| public void restore(Version version, boolean removeExisting) |
| throws RepositoryException { |
| restore(version, ".", removeExisting); |
| } |
| |
| /** |
| * Restores this node to the version with the given label. |
| * <p> |
| * The default implement retrieves the labeled {@link Version} from the |
| * associated {@link VersionHistory} and forwards the call to the |
| * {@link Node#restore(Version, boolean)} method. |
| * |
| * @param versionLabel version label |
| * @param removeExisting passed through |
| * @throws RepositoryException if an error occurs |
| */ |
| public void restoreByLabel(String versionLabel, boolean removeExisting) |
| throws RepositoryException { |
| restore(getVersionHistory().getVersionByLabel(versionLabel), |
| removeExisting); |
| } |
| |
| /** |
| * Sets the value of the named property. |
| * <p> |
| * The default implementation uses the {@link ValueFactory} of the |
| * current {@link Session} to create a {@link Value} instances from |
| * the given string values and forwards the call to the |
| * {@link Node#setProperty(String, Value[])} method. |
| * |
| * @param name property name |
| * @param strings string values |
| * @return modified property |
| * @throws RepositoryException if an error occurs |
| */ |
| public Property setProperty(String name, String[] strings) |
| throws RepositoryException { |
| ValueFactory factory = getSession().getValueFactory(); |
| Value[] values = new Value[strings.length]; |
| for (int i = 0; i < strings.length; i++) { |
| values[i] = factory.createValue(strings[i]); |
| } |
| return setProperty(name, values); |
| } |
| |
| /** |
| * Sets the value of the named property. |
| * <p> |
| * The default implementation uses the {@link ValueFactory} of the |
| * current {@link Session} to create a {@link Value} instance from |
| * the given string value and forwards the call to the |
| * {@link Node#setProperty(String, Value)} method. |
| * |
| * @param name property name |
| * @param value string value |
| * @return modified property |
| * @throws RepositoryException if an error occurs |
| */ |
| public Property setProperty(String name, String value) |
| throws RepositoryException { |
| ValueFactory factory = getSession().getValueFactory(); |
| return setProperty(name, factory.createValue(value)); |
| } |
| |
| /** |
| * Sets the value of the named property. |
| * <p> |
| * The default implementation uses the {@link ValueFactory} of the |
| * current {@link Session} to create a {@link Value} instance from |
| * the given binary value and forwards the call to the |
| * {@link Node#setProperty(String, Value)} method. |
| * |
| * @param name property name |
| * @param value binary value |
| * @return modified property |
| * @throws RepositoryException if an error occurs |
| */ |
| public Property setProperty(String name, InputStream value) |
| throws RepositoryException { |
| ValueFactory factory = getSession().getValueFactory(); |
| return setProperty(name, factory.createValue(value)); |
| } |
| |
| /** |
| * Sets the value of the named property. |
| * <p> |
| * The default implementation uses the {@link ValueFactory} of the |
| * current {@link Session} to create a {@link Value} instance from |
| * the given boolean value and forwards the call to the |
| * {@link Node#setProperty(String, Value)} method. |
| * |
| * @param name property name |
| * @param value boolean value |
| * @return modified property |
| * @throws RepositoryException if an error occurs |
| */ |
| public Property setProperty(String name, boolean value) |
| throws RepositoryException { |
| ValueFactory factory = getSession().getValueFactory(); |
| return setProperty(name, factory.createValue(value)); |
| } |
| |
| /** |
| * Sets the value of the named property. |
| * <p> |
| * The default implementation uses the {@link ValueFactory} of the |
| * current {@link Session} to create a {@link Value} instance from |
| * the given double value and forwards the call to the |
| * {@link Node#setProperty(String, Value)} method. |
| * |
| * @param name property name |
| * @param value double value |
| * @return modified property |
| * @throws RepositoryException if an error occurs |
| */ |
| public Property setProperty(String name, double value) |
| throws RepositoryException { |
| ValueFactory factory = getSession().getValueFactory(); |
| return setProperty(name, factory.createValue(value)); |
| } |
| |
| /** |
| * Sets the value of the named property. |
| * <p> |
| * The default implementation uses the {@link ValueFactory} of the |
| * current {@link Session} to create a {@link Value} instance from |
| * the given long value and forwards the call to the |
| * {@link Node#setProperty(String, Value)} method. |
| * |
| * @param name property name |
| * @param value long value |
| * @return modified property |
| * @throws RepositoryException if an error occurs |
| */ |
| public Property setProperty(String name, long value) |
| throws RepositoryException { |
| ValueFactory factory = getSession().getValueFactory(); |
| return setProperty(name, factory.createValue(value)); |
| } |
| |
| /** |
| * Sets the value of the named property. |
| * <p> |
| * The default implementation uses the {@link ValueFactory} of the |
| * current {@link Session} to create a {@link Value} instance from |
| * the given date value and forwards the call to the |
| * {@link Node#setProperty(String, Value)} method. |
| * |
| * @param name property name |
| * @param value date value |
| * @return modified property |
| * @throws RepositoryException if an error occurs |
| */ |
| public Property setProperty(String name, Calendar value) |
| throws RepositoryException { |
| ValueFactory factory = getSession().getValueFactory(); |
| return setProperty(name, factory.createValue(value)); |
| } |
| |
| /** |
| * Sets the value of the named property. |
| * <p> |
| * The default implementation uses the {@link ValueFactory} of the |
| * current {@link Session} to create a {@link Value} instance from |
| * the given reference value and forwards the call to the |
| * {@link Node#setProperty(String, Value)} method. |
| * |
| * @param name property name |
| * @param value reference value |
| * @return modified property |
| * @throws RepositoryException if an error occurs |
| */ |
| public Property setProperty(String name, Node value) |
| throws RepositoryException { |
| ValueFactory factory = getSession().getValueFactory(); |
| return setProperty(name, factory.createValue(value)); |
| } |
| |
| /** |
| * Sets the value of the named property. |
| * <p> |
| * The default implementation uses the {@link ValueFactory} of the |
| * current {@link Session} to convert the given value to the given |
| * type and forwards the call to the |
| * {@link Node#setProperty(String, Value)} method. |
| * |
| * @param name property name |
| * @param value property value |
| * @param type property type |
| * @return modified property |
| * @throws RepositoryException if an error occurs |
| */ |
| public Property setProperty(String name, Value value, int type) |
| throws RepositoryException { |
| if (value.getType() != type) { |
| ValueFactory factory = getSession().getValueFactory(); |
| value = factory.createValue(value.getString(), type); |
| } |
| return setProperty(name, value); |
| } |
| |
| /** |
| * Sets the value of the named property. |
| * <p> |
| * The default implementation uses the {@link ValueFactory} of the |
| * current {@link Session} to convert the given values to the given |
| * type and forwards the call to the |
| * {@link Node#setProperty(String, Value[])} method. |
| * |
| * @param name property name |
| * @param values property values |
| * @param type property type |
| * @return modified property |
| * @throws RepositoryException if an error occurs |
| */ |
| public Property setProperty(String name, Value[] values, int type) |
| throws RepositoryException { |
| ValueFactory factory = getSession().getValueFactory(); |
| Value[] converted = new Value[values.length]; |
| for (int i = 0; i < values.length; i++) { |
| if (values[i].getType() != type) { |
| converted[i] = factory.createValue(values[i].getString(), type); |
| } else { |
| converted[i] = values[i]; |
| } |
| } |
| return setProperty(name, converted); |
| } |
| |
| /** |
| * Sets the value of the named property. |
| * <p> |
| * The default implementation uses the {@link ValueFactory} of the |
| * current {@link Session} to create {@link Value} instances of the |
| * given type from the given string values and forwards the call to the |
| * {@link Node#setProperty(String, Value[])} method. |
| * |
| * @param name property name |
| * @param strings string values |
| * @param type property type |
| * @return modified property |
| * @throws RepositoryException if an error occurs |
| */ |
| public Property setProperty(String name, String[] strings, int type) |
| throws RepositoryException { |
| ValueFactory factory = getSession().getValueFactory(); |
| Value[] values = new Value[strings.length]; |
| for (int i = 0; i < strings.length; i++) { |
| values[i] = factory.createValue(strings[i], type); |
| } |
| return setProperty(name, values); |
| } |
| |
| /** |
| * Sets the value of the named property. |
| * <p> |
| * The default implementation uses the {@link ValueFactory} of the |
| * current {@link Session} to create a {@link Value} instance of the |
| * given type from the given string value and forwards the call to the |
| * {@link Node#setProperty(String, Value)} method. |
| * |
| * @param name property name |
| * @param value string value |
| * @param type property type |
| * @return modified property |
| * @throws RepositoryException if an error occurs |
| */ |
| public Property setProperty(String name, String value, int type) |
| throws RepositoryException { |
| ValueFactory factory = getSession().getValueFactory(); |
| return setProperty(name, factory.createValue(value, type)); |
| } |
| |
| //-------------------------------------------------------------< private > |
| |
| /** |
| * Returns the prefixed JCR name for the namespace URI and local name |
| * using the current namespace mappings. |
| * |
| * @param uri namespace URI |
| * @param name namespace-local name |
| * @return prefixed JCR name |
| * @throws RepositoryException if an error occurs |
| */ |
| private String getName(String name) throws RepositoryException { |
| return new NamespaceHelper(getSession()).getJcrName(name); |
| } |
| |
| } |
