/*
* 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 static java.net.URLDecoder.decode;
import java.io.FilterInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.math.BigDecimal;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;
import javax.imageio.spi.ServiceRegistry;
import javax.jcr.Binary;
import javax.jcr.Item;
import javax.jcr.Node;
import javax.jcr.NodeIterator;
import javax.jcr.PathNotFoundException;
import javax.jcr.Property;
import javax.jcr.PropertyIterator;
import javax.jcr.PropertyType;
import javax.jcr.Repository;
import javax.jcr.RepositoryException;
import javax.jcr.RepositoryFactory;
import javax.jcr.Session;
import javax.jcr.Value;
import javax.jcr.nodetype.NodeType;
import javax.jcr.nodetype.NodeTypeIterator;
import javax.jcr.observation.Event;
import javax.jcr.observation.EventIterator;
import javax.jcr.observation.EventListener;
import javax.jcr.observation.EventListenerIterator;
import javax.jcr.query.QueryResult;
import javax.jcr.query.Row;
import javax.jcr.query.RowIterator;
import javax.jcr.security.AccessControlPolicyIterator;
import javax.jcr.version.Version;
import javax.jcr.version.VersionIterator;
/**
* Collection of static utility methods for use with the JCR API.
*
* @since Apache Jackrabbit 2.0
*/
public class JcrUtils {
/**
* The repository URI parameter name used by the
* {@link #getRepository(String)} method. All {@link RepositoryFactory}
* implementations that want to support this repository access convention
* should implement processing of this parameter.
* <p>
* Client applications are recommended to use the
* {@link #getRepository(String)} method instead of directly referencing
* this constant unless they explicitly want to pass also other
* {@link RepositoryFactory} parameters through the
* {@link #getRepository(Map)} method.
*/
public static final String REPOSITORY_URI = "org.apache.jackrabbit.repository.uri";
/**
* A pre-allocated empty array of values.
*
* @since Apache Jackrabbit 2.3
*/
public static final Value[] NO_VALUES = new Value[0];
/**
* Private constructor to prevent instantiation of this class.
*/
private JcrUtils() {
}
/**
* Returns the default repository of the current environment.
* Implemented by calling {@link #getRepository(Map)} with a
* <code>null</code> parameter map.
*
* @see RepositoryFactory#getRepository(Map)
* @return default repository
* @throws RepositoryException if a default repository is not available
* or can not be accessed
*/
public static Repository getRepository() throws RepositoryException {
return getRepository((Map<String, String>) null);
}
/**
* Looks up the available {@link RepositoryFactory repository factories}
* and returns the {@link Repository repository} that one of the factories
* returns for the given settings.
* <p>
* Note that unlike {@link RepositoryFactory#getRepository(Map)} this
* method will throw an exception instead of returning <code>null</code>
* if the given parameters can not be interpreted.
*
* @param parameters repository settings
* @return repository reference
* @throws RepositoryException if the repository can not be accessed,
* or if an appropriate repository factory
* is not available
*/
public static Repository getRepository(Map<String, String> parameters)
throws RepositoryException {
String newline = System.getProperty("line.separator");
// Prepare the potential error message (JCR-2459)
StringBuilder log = new StringBuilder("Unable to access a repository");
if (parameters != null) {
log.append(" with the following settings:");
for (Map.Entry<String, String> entry : parameters.entrySet()) {
log.append(newline);
log.append(" ");
log.append(entry.getKey());
log.append(": ");
log.append(entry.getValue());
}
} else {
log.append(" with the default settings.");
}
// Use the query part of a repository URI as additional parameters
if (parameters != null
&& parameters.containsKey(JcrUtils.REPOSITORY_URI)) {
String uri = parameters.get(JcrUtils.REPOSITORY_URI);
try {
URI u = new URI(uri);
String query = u.getRawQuery();
if (query != null) {
Map<String, String> copy = new HashMap<String, String>(parameters);
for (String entry : query.split("&")) {
int i = entry.indexOf('=');
if (i != -1) {
copy.put(
decode(entry.substring(0, i), "UTF-8"),
decode(entry.substring(i + 1), "UTF-8"));
} else {
copy.put(
decode(entry, "UTF-8"),
Boolean.TRUE.toString());
}
}
copy.put(
JcrUtils.REPOSITORY_URI,
new URI(u.getScheme(), u.getRawAuthority(),
u.getRawPath(), null, u.getRawFragment()
).toASCIIString());
parameters = copy;
}
} catch (URISyntaxException e) {
log.append(newline);
log.append("Note that the given repository URI was invalid:");
log.append(newline);
log.append(" ").append(uri);
log.append(newline);
log.append(" ").append(e.getMessage());
} catch (UnsupportedEncodingException e) {
throw new RepositoryException("UTF-8 is not supported!", e);
}
}
// Iterate through the available RepositoryFactories, with logging
log.append(newline);
log.append("The following RepositoryFactory classes were consulted:");
Iterator<RepositoryFactory> iterator =
ServiceRegistry.lookupProviders(RepositoryFactory.class);
while (iterator.hasNext()) {
RepositoryFactory factory = iterator.next();
log.append(newline);
log.append(" ");
log.append(factory.getClass().getName());
try {
Repository repository = factory.getRepository(parameters);
if (repository != null) {
// We found the requested repository! Return it
// and just ignore the error message being built.
return repository;
} else {
log.append(": declined");
}
} catch (Exception e) {
log.append(": failed");
for (Throwable c = e; c != null; c = c.getCause()) {
log.append(newline);
log.append(" because of ");
log.append(c.getClass().getSimpleName());
log.append(": ");
log.append(c.getMessage());
}
}
}
log.append(newline);
log.append(
"Perhaps the repository you are trying"
+ " to access is not available at the moment.");
// No matching repository found. Throw an exception with the
// detailed information we gathered during the above process.
throw new RepositoryException(log.toString());
}
/**
* Returns the repository identified by the given URI. This feature
* is implemented by calling the {@link #getRepository(Map)} method
* with the {@link #REPOSITORY_URI} parameter set to the given URI.
* Any query parameters are moved from the URI to the parameter map.
* <p>
* See the documentation of the repository implementation you want
* to use for whether it supports this repository URI convention and
* for what the repository URI should look like. For example,
* Jackrabbit 2.0 supports the following types of repository URIs:
* <dl>
* <dt>http(s)://...</dt>
* <dd>
* A remote repository connection using SPI2DAVex with the given URL.
* See the jackrabbit-jcr2dav component for more details.
* </dd>
* <dt>file://...</dt>
* <dd>
* An embedded Jackrabbit repository located in the given directory.
* See the jackrabbit-core component for more details.
* </dd>
* <dt>jndi:...</dt>
* <dd>
* JNDI lookup for the named repository. See the
* {@link JndiRepositoryFactory} class for more details.
* </dd>
* </dl>
*
* @param uri repository URI
* @return repository instance
* @throws RepositoryException if the repository can not be accessed,
* or if the given URI is unknown or invalid
*/
public static Repository getRepository(String uri)
throws RepositoryException {
Map<String, String> parameters = new HashMap<String, String>();
parameters.put(JcrUtils.REPOSITORY_URI, uri);
return getRepository(parameters);
}
/**
* Returns an {@link Iterable<Node>} over the shared set of the given node.
* <p>
* The first iterator is acquired directly during this method call to
* allow a possible {@link RepositoryException} to be thrown as-is.
* Further iterators are acquired lazily when needed, with possible
* {@link RepositoryException}s wrapped into {@link RuntimeException}s.
*
* @see Node#getSharedSet()
* @param node shared node
* @return nodes in the shared set
* @throws RepositoryException if the {@link Node#getSharedSet()} call fails
*/
public static Iterable<Node> getSharedSet(final Node node)
throws RepositoryException {
final NodeIterator iterator = node.getSharedSet();
return new Iterable<Node>() {
private boolean first = true;
@Override @SuppressWarnings("unchecked")
public synchronized Iterator<Node> iterator() {
if (first) {
first = false;
return iterator;
} else {
try {
return node.getSharedSet();
} catch (RepositoryException e) {
throw new RuntimeException(e);
}
}
}
};
}
/**
* Returns an {@link Iterable<Node>} over the children of the given node.
* <p>
* The first iterator is acquired directly during this method call to
* allow a possible {@link RepositoryException} to be thrown as-is.
* Further iterators are acquired lazily when needed, with possible
* {@link RepositoryException}s wrapped into {@link RuntimeException}s.
*
* @see Node#getNodes()
* @param node parent node
* @return child nodes
* @throws RepositoryException if the {@link Node#getNodes()} call fails
*/
public static Iterable<Node> getChildNodes(final Node node)
throws RepositoryException {
final NodeIterator iterator = node.getNodes();
return new Iterable<Node>() {
private boolean first = true;
@Override @SuppressWarnings("unchecked")
public synchronized Iterator<Node> iterator() {
if (first) {
first = false;
return iterator;
} else {
try {
return node.getNodes();
} catch (RepositoryException e) {
throw new RuntimeException(e);
}
}
}
};
}
/**
* Returns an {@link Iterable<Node>} over those children of the given node
* that match the given name pattern.
* <p>
* The first iterator is acquired directly during this method call to
* allow a possible {@link RepositoryException} to be thrown as-is.
* Further iterators are acquired lazily when needed, with possible
* {@link RepositoryException}s wrapped into {@link RuntimeException}s.
*
* @see Node#getNodes(String)
* @param node parent node
* @param pattern node name pattern
* @return matching child nodes
* @throws RepositoryException
* if the {@link Node#getNodes(String)} call fails
*/
public static Iterable<Node> getChildNodes(
final Node node, final String pattern) throws RepositoryException {
final NodeIterator iterator = node.getNodes(pattern);
return new Iterable<Node>() {
private boolean first = true;
@Override @SuppressWarnings("unchecked")
public synchronized Iterator<Node> iterator() {
if (first) {
first = false;
return iterator;
} else {
try {
return node.getNodes(pattern);
} catch (RepositoryException e) {
throw new RuntimeException(e);
}
}
}
};
}
/**
* Returns an {@link Iterable<Node>} over those children of the given node
* that match the given name patterns.
* <p>
* The first iterator is acquired directly during this method call to
* allow a possible {@link RepositoryException} to be thrown as-is.
* Further iterators are acquired lazily when needed, with possible
* {@link RepositoryException}s wrapped into {@link RuntimeException}s.
*
* @see Node#getNodes(String[])
* @param node parent node
* @param globs node name pattern
* @return matching child nodes
* @throws RepositoryException
* if the {@link Node#getNodes(String[])} call fails
*/
public static Iterable<Node> getChildNodes(
final Node node, final String[] globs) throws RepositoryException {
final NodeIterator iterator = node.getNodes(globs);
return new Iterable<Node>() {
private boolean first = true;
@Override @SuppressWarnings("unchecked")
public synchronized Iterator<Node> iterator() {
if (first) {
first = false;
return iterator;
} else {
try {
return node.getNodes(globs);
} catch (RepositoryException e) {
throw new RuntimeException(e);
}
}
}
};
}
/**
* Returns an {@link Iterable<Node>} over the properties of the given node.
* <p>
* The first iterator is acquired directly during this method call to
* allow a possible {@link RepositoryException} to be thrown as-is.
* Further iterators are acquired lazily when needed, with possible
* {@link RepositoryException}s wrapped into {@link RuntimeException}s.
*
* @see Node#getProperties()
* @param node node
* @return properties of the node
* @throws RepositoryException
* if the {@link Node#getProperties()} call fails
*/
public static Iterable<Property> getProperties(final Node node)
throws RepositoryException {
final PropertyIterator iterator = node.getProperties();
return new Iterable<Property>() {
private boolean first = true;
@Override @SuppressWarnings("unchecked")
public synchronized Iterator<Property> iterator() {
if (first) {
first = false;
return iterator;
} else {
try {
return node.getProperties();
} catch (RepositoryException e) {
throw new RuntimeException(e);
}
}
}
};
}
/**
* Returns an {@link Iterable<Node>} over those properties of the
* given node that match the given name pattern.
* <p>
* The first iterator is acquired directly during this method call to
* allow a possible {@link RepositoryException} to be thrown as-is.
* Further iterators are acquired lazily when needed, with possible
* {@link RepositoryException}s wrapped into {@link RuntimeException}s.
*
* @see Node#getProperties(String)
* @param node node
* @param pattern property name pattern
* @return matching properties of the node
* @throws RepositoryException
* if the {@link Node#getProperties(String)} call fails
*/
public static Iterable<Property> getProperties(
final Node node, final String pattern) throws RepositoryException {
final PropertyIterator iterator = node.getProperties(pattern);
return new Iterable<Property>() {
private boolean first = true;
@Override @SuppressWarnings("unchecked")
public synchronized Iterator<Property> iterator() {
if (first) {
first = false;
return iterator;
} else {
try {
return node.getProperties(pattern);
} catch (RepositoryException e) {
throw new RuntimeException(e);
}
}
}
};
}
/**
* Returns an {@link Iterable<Node>} over those properties of the
* given node that match the given name patterns.
* <p>
* The first iterator is acquired directly during this method call to
* allow a possible {@link RepositoryException} to be thrown as-is.
* Further iterators are acquired lazily when needed, with possible
* {@link RepositoryException}s wrapped into {@link RuntimeException}s.
*
* @see Node#getProperties(String[])
* @param node node
* @param globs property name globs
* @return matching properties of the node
* @throws RepositoryException
* if the {@link Node#getProperties(String[])} call fails
*/
public static Iterable<Property> getProperties(
final Node node, final String[] globs) throws RepositoryException {
final PropertyIterator iterator = node.getProperties(globs);
return new Iterable<Property>() {
private boolean first = true;
@Override @SuppressWarnings("unchecked")
public synchronized Iterator<Property> iterator() {
if (first) {
first = false;
return iterator;
} else {
try {
return node.getProperties(globs);
} catch (RepositoryException e) {
throw new RuntimeException(e);
}
}
}
};
}
/**
* Returns an {@link Iterable<Node>} over references to the given node.
* <p>
* The first iterator is acquired directly during this method call to
* allow a possible {@link RepositoryException} to be thrown as-is.
* Further iterators are acquired lazily when needed, with possible
* {@link RepositoryException}s wrapped into {@link RuntimeException}s.
*
* @see Node#getReferences()
* @param node reference target
* @return references that point to the given node
* @throws RepositoryException
* if the {@link Node#getReferences()} call fails
*/
public static Iterable<Property> getReferences(final Node node)
throws RepositoryException {
final PropertyIterator iterator = node.getReferences();
return new Iterable<Property>() {
private boolean first = true;
@Override @SuppressWarnings("unchecked")
public synchronized Iterator<Property> iterator() {
if (first) {
first = false;
return iterator;
} else {
try {
return node.getReferences();
} catch (RepositoryException e) {
throw new RuntimeException(e);
}
}
}
};
}
/**
* Returns an {@link Iterable<Node>} over those references to the
* given node that have the given name.
* <p>
* The first iterator is acquired directly during this method call to
* allow a possible {@link RepositoryException} to be thrown as-is.
* Further iterators are acquired lazily when needed, with possible
* {@link RepositoryException}s wrapped into {@link RuntimeException}s.
*
* @see Node#getReferences(String)
* @param node reference target
* @param name reference property name
* @return references with the given name that point to the given node
* @throws RepositoryException
* if the {@link Node#getReferences(String)} call fails
*/
public static Iterable<Property> getReferences(
final Node node, final String name) throws RepositoryException {
final PropertyIterator iterator = node.getReferences(name);
return new Iterable<Property>() {
private boolean first = true;
@Override @SuppressWarnings("unchecked")
public synchronized Iterator<Property> iterator() {
if (first) {
first = false;
return iterator;
} else {
try {
return node.getReferences(name);
} catch (RepositoryException e) {
throw new RuntimeException(e);
}
}
}
};
}
/**
* Returns an {@link Iterable<Node>} over weak references to the given node.
* <p>
* The first iterator is acquired directly during this method call to
* allow a possible {@link RepositoryException} to be thrown as-is.
* Further iterators are acquired lazily when needed, with possible
* {@link RepositoryException}s wrapped into {@link RuntimeException}s.
*
* @see Node#getWeakReferences()
* @param node reference target
* @return weak references that point to the given node
* @throws RepositoryException
* if the {@link Node#getWeakReferences()} call fails
*/
public static Iterable<Property> getWeakReferences(final Node node)
throws RepositoryException {
final PropertyIterator iterator = node.getWeakReferences();
return new Iterable<Property>() {
private boolean first = true;
@Override @SuppressWarnings("unchecked")
public synchronized Iterator<Property> iterator() {
if (first) {
first = false;
return iterator;
} else {
try {
return node.getWeakReferences();
} catch (RepositoryException e) {
throw new RuntimeException(e);
}
}
}
};
}
/**
* Returns an {@link Iterable<Node>} over those weak references to the
* given node that have the given name.
* <p>
* The first iterator is acquired directly during this method call to
* allow a possible {@link RepositoryException} to be thrown as-is.
* Further iterators are acquired lazily when needed, with possible
* {@link RepositoryException}s wrapped into {@link RuntimeException}s.
*
* @see Node#getWeakReferences(String)
* @param node reference target
* @param name reference property name
* @return weak references with the given name that point to the given node
* @throws RepositoryException
* if the {@link Node#getWeakReferences(String)} call fails
*/
public static Iterable<Property> getWeakReferences(
final Node node, final String name) throws RepositoryException {
final PropertyIterator iterator = node.getWeakReferences(name);
return new Iterable<Property>() {
private boolean first = true;
@Override @SuppressWarnings("unchecked")
public synchronized Iterator<Property> iterator() {
if (first) {
first = false;
return iterator;
} else {
try {
return node.getWeakReferences(name);
} catch (RepositoryException e) {
throw new RuntimeException(e);
}
}
}
};
}
/**
* Returns an {@link Iterable<Node>} over nodes in the given query result.
* <p>
* The first iterator is acquired directly during this method call to
* allow a possible {@link RepositoryException} to be thrown as-is.
* Further iterators are acquired lazily when needed, with possible
* {@link RepositoryException}s wrapped into {@link RuntimeException}s.
*
* @see QueryResult#getNodes()
* @param result query result
* @return nodes in the query result
* @throws RepositoryException
* if the {@link QueryResult#getNodes()} call fails
*/
public static Iterable<Node> getNodes(final QueryResult result)
throws RepositoryException {
final NodeIterator iterator = result.getNodes();
return new Iterable<Node>() {
private boolean first = true;
@Override @SuppressWarnings("unchecked")
public synchronized Iterator<Node> iterator() {
if (first) {
first = false;
return iterator;
} else {
try {
return result.getNodes();
} catch (RepositoryException e) {
throw new RuntimeException(e);
}
}
}
};
}
/**
* Returns an {@link Iterable<Row>} over nodes in the given query result.
* <p>
* The first iterator is acquired directly during this method call to
* allow a possible {@link RepositoryException} to be thrown as-is.
* Further iterators are acquired lazily when needed, with possible
* {@link RepositoryException}s wrapped into {@link RuntimeException}s.
*
* @see QueryResult#getRows()
* @param result query result
* @return rows in the query result
* @throws RepositoryException
* if the {@link QueryResult#getRows()} call fails
*/
public static Iterable<Row> getRows(final QueryResult result)
throws RepositoryException {
final RowIterator iterator = result.getRows();
return new Iterable<Row>() {
private boolean first = true;
@Override @SuppressWarnings("unchecked")
public synchronized Iterator<Row> iterator() {
if (first) {
first = false;
return iterator;
} else {
try {
return result.getRows();
} catch (RepositoryException e) {
throw new RuntimeException(e);
}
}
}
};
}
/**
* Transform any type of {@link Iterator} into an {@link Iterable}
* <strong>for single use</strong> in a Java 5 for-each loop.
* <p>
* <strong>While general purpose <code>Iterables</code> tend to be reusable,
* this wrapper <code>Iterable</code> consumes the argument
* <code>Iterator</code>, leaving it in a non-reusable state. The returned
* <code>Iterable</code> will throw an <code>IllegalStateException</code> if
* its <code>iterator()</code> method is invoked a second time.</strong>
*
* @param iterator
* The input <code>Iterator</code>
* @return The wrapping <code>Iterable</code>
*/
public static <I> Iterable<I> in(final Iterator<I> iterator) {
return new Iterable<I>() {
private boolean stale = false;
@Override
public synchronized Iterator<I> iterator() {
if (stale) {
throw new IllegalStateException("Cannot reuse Iterable intended for single use");
}
stale = true;
return iterator;
}
};
}
/**
* Transform an {@link AccessControlPolicyIterator} into an {@link Iterable}
* <strong>for single use</strong> in a Java 5 for-each loop.
* <p>
* <strong>While general purpose <code>Iterables</code> tend to be reusable,
* this wrapper <code>Iterable</code> consumes the argument
* <code>Iterator</code>, leaving it in a non-reusable state. The returned
* <code>Iterable</code> will throw an <code>IllegalStateException</code> if
* its <code>iterator()</code> method is invoked a second time.</strong>
*
* @param iterator
* The input <code>Iterator</code>
* @return The wrapping <code>Iterable</code>
*/
@SuppressWarnings("unchecked")
public static Iterable<AccessControlPolicyIterator> in(AccessControlPolicyIterator iterator) {
return in((Iterator<AccessControlPolicyIterator>) iterator);
}
/**
* Transform an {@link EventIterator} into an {@link Iterable}
* <strong>for single use</strong> in a Java 5 for-each loop.
* <p>
* <strong>While general purpose <code>Iterables</code> tend to be reusable,
* this wrapper <code>Iterable</code> consumes the argument
* <code>Iterator</code>, leaving it in a non-reusable state. The returned
* <code>Iterable</code> will throw an <code>IllegalStateException</code> if
* its <code>iterator()</code> method is invoked a second time.</strong>
*
* @param iterator
* The input <code>Iterator</code>
* @return The wrapping <code>Iterable</code>
*/
@SuppressWarnings("unchecked")
public static Iterable<Event> in(EventIterator iterator) {
return in((Iterator<Event>) iterator);
}
/**
* Transform an {@link EventListenerIterator} into an {@link Iterable}
* <strong>for single use</strong> in a Java 5 for-each loop.
* <p>
* <strong>While general purpose <code>Iterables</code> tend to be reusable,
* this wrapper <code>Iterable</code> consumes the argument
* <code>Iterator</code>, leaving it in a non-reusable state. The returned
* <code>Iterable</code> will throw an <code>IllegalStateException</code> if
* its <code>iterator()</code> method is invoked a second time.</strong>
*
* @param iterator
* The input <code>Iterator</code>
* @return The wrapping <code>Iterable</code>
*/
@SuppressWarnings("unchecked")
public static Iterable<EventListener> in(EventListenerIterator iterator) {
return in((Iterator<EventListener>) iterator);
}
/**
* Transform an {@link NodeIterator} into an {@link Iterable}
* <strong>for single use</strong> in a Java 5 for-each loop.
* <p>
* <strong>While general purpose <code>Iterables</code> tend to be reusable,
* this wrapper <code>Iterable</code> consumes the argument
* <code>Iterator</code>, leaving it in a non-reusable state. The returned
* <code>Iterable</code> will throw an <code>IllegalStateException</code> if
* its <code>iterator()</code> method is invoked a second time.</strong>
*
* @param iterator
* The input <code>Iterator</code>
* @return The wrapping <code>Iterable</code>
*/
@SuppressWarnings("unchecked")
public static Iterable<Node> in(NodeIterator iterator) {
return in((Iterator<Node>) iterator);
}
/**
* Transform an {@link NodeTypeIterator} into an {@link Iterable}
* <strong>for single use</strong> in a Java 5 for-each loop.
* <p>
* <strong>While general purpose <code>Iterables</code> tend to be reusable,
* this wrapper <code>Iterable</code> consumes the argument
* <code>Iterator</code>, leaving it in a non-reusable state. The returned
* <code>Iterable</code> will throw an <code>IllegalStateException</code> if
* its <code>iterator()</code> method is invoked a second time.</strong>
*
* @param iterator
* The input <code>Iterator</code>
* @return The wrapping <code>Iterable</code>
*/
@SuppressWarnings("unchecked")
public static Iterable<NodeType> in(NodeTypeIterator iterator) {
return in((Iterator<NodeType>) iterator);
}
/**
* Transform an {@link PropertyIterator} into an {@link Iterable}
* <strong>for single use</strong> in a Java 5 for-each loop.
* <p>
* <strong>While general purpose <code>Iterables</code> tend to be reusable,
* this wrapper <code>Iterable</code> consumes the argument
* <code>Iterator</code>, leaving it in a non-reusable state. The returned
* <code>Iterable</code> will throw an <code>IllegalStateException</code> if
* its <code>iterator()</code> method is invoked a second time.</strong>
*
* @param iterator
* The input <code>Iterator</code>
* @return The wrapping <code>Iterable</code>
*/
@SuppressWarnings("unchecked")
public static Iterable<Property> in(PropertyIterator iterator) {
return in((Iterator<Property>) iterator);
}
/**
* Transform an {@link RowIterator} into an {@link Iterable}
* <strong>for single use</strong> in a Java 5 for-each loop.
* <p>
* <strong>While general purpose <code>Iterables</code> tend to be reusable,
* this wrapper <code>Iterable</code> consumes the argument
* <code>Iterator</code>, leaving it in a non-reusable state. The returned
* <code>Iterable</code> will throw an <code>IllegalStateException</code> if
* its <code>iterator()</code> method is invoked a second time.</strong>
*
* @param iterator
* The input <code>Iterator</code>
* @return The wrapping <code>Iterable</code>
*/
@SuppressWarnings("unchecked")
public static Iterable<Row> in(RowIterator iterator) {
return in((Iterator<Row>) iterator);
}
/**
* Transform an {@link VersionIterator} into an {@link Iterable}
* <strong>for single use</strong> in a Java 5 for-each loop.
* <p>
* <strong>While general purpose <code>Iterables</code> tend to be reusable,
* this wrapper <code>Iterable</code> consumes the argument
* <code>Iterator</code>, leaving it in a non-reusable state. The returned
* <code>Iterable</code> will throw an <code>IllegalStateException</code> if
* its <code>iterator()</code> method is invoked a second time.</strong>
*
* @param iterator
* The input <code>Iterator</code>
* @return The wrapping <code>Iterable</code>
*/
@SuppressWarnings("unchecked")
public static Iterable<Version> in(VersionIterator iterator) {
return in((Iterator<Version>) iterator);
}
/**
* Returns the named child of the given node, creating the child if
* it does not already exist. If the child node gets added, then its
* type will be determined by the child node definitions associated
* with the parent node. The caller is expected to take care of saving
* or discarding any transient changes.
*
* @see Node#getNode(String)
* @see Node#addNode(String)
* @param parent parent node
* @param name name of the child node
* @return the child node
* @throws RepositoryException if the child node can not be
* accessed or created
*/
public static Node getOrAddNode(Node parent, String name)
throws RepositoryException {
return getOrAddNode(parent, name, null);
}
/**
* Returns the named child of the given node, creating the child if
* it does not already exist. If the child node gets added, then it
* is created with the given node type. The caller is expected to take
* care of saving or discarding any transient changes.
*
* @see Node#getNode(String)
* @see Node#addNode(String, String)
* @see Node#isNodeType(String)
* @param parent parent node
* @param name name of the child node
* @param type type of the child node or {@code null},
* ignored if the child already exists
* @return the child node
* @throws RepositoryException if the child node can not be accessed
* or created
*/
public static Node getOrAddNode(Node parent, String name, String type)
throws RepositoryException {
if (parent.hasNode(name)) {
return parent.getNode(name);
} else if (type != null) {
return parent.addNode(name, type);
} else {
return parent.addNode(name);
}
}
/**
* Returns the named child of the given node, creating it as an
* nt:folder node if it does not already exist. The caller is expected
* to take care of saving or discarding any transient changes.
* <p>
* Note that the type of the returned node is <em>not</em> guaranteed
* to match nt:folder in case the node already existed. The caller can
* use an explicit {@link Node#isNodeType(String)} check if needed, or
* simply use a data-first approach and not worry about the node type
* until a constraint violation is encountered.
*
* @param parent parent node
* @param name name of the child node
* @return the child node
* @throws RepositoryException if the child node can not be accessed
* or created
*/
public static Node getOrAddFolder(Node parent, String name)
throws RepositoryException {
return getOrAddNode(parent, name, NodeType.NT_FOLDER);
}
/**
* Creates or updates the named child of the given node. If the child
* does not already exist, then it is created using the nt:file node type.
* This file child node is returned from this method.
* <p>
* If the file node does not already contain a jcr:content child, then
* one is created using the nt:resource node type. The following
* properties are set on the jcr:content node:
* <dl>
* <dt>jcr:mimeType</dt>
* <dd>media type</dd>
* <dt>jcr:encoding (optional)</dt>
* <dd>charset parameter of the media type, if any</dd>
* <dt>jcr:lastModified</dt>
* <dd>current time</dd>
* <dt>jcr:data</dt>
* <dd>binary content</dd>
* </dl>
* <p>
* Note that the types of the returned node or the jcr:content child are
* <em>not</em> guaranteed to match nt:file and nt:resource in case the
* nodes already existed. The caller can use an explicit
* {@link Node#isNodeType(String)} check if needed, or simply use a
* data-first approach and not worry about the node type until a constraint
* violation is encountered.
* <p>
* The given binary content stream is closed by this method.
*
* @param parent parent node
* @param name name of the file
* @param mime media type of the file
* @param data binary content of the file
* @return the child node
* @throws RepositoryException if the child node can not be created
* or updated
*/
public static Node putFile(
Node parent, String name, String mime, InputStream data)
throws RepositoryException {
return putFile(parent, name, mime, data, Calendar.getInstance());
}
/**
* Creates or updates the named child of the given node. If the child
* does not already exist, then it is created using the nt:file node type.
* This file child node is returned from this method.
* <p>
* If the file node does not already contain a jcr:content child, then
* one is created using the nt:resource node type. The following
* properties are set on the jcr:content node:
* <dl>
* <dt>jcr:mimeType</dt>
* <dd>media type</dd>
* <dt>jcr:encoding (optional)</dt>
* <dd>charset parameter of the media type, if any</dd>
* <dt>jcr:lastModified</dt>
* <dd>date of last modification</dd>
* <dt>jcr:data</dt>
* <dd>binary content</dd>
* </dl>
* <p>
* Note that the types of the returned node or the jcr:content child are
* <em>not</em> guaranteed to match nt:file and nt:resource in case the
* nodes already existed. The caller can use an explicit
* {@link Node#isNodeType(String)} check if needed, or simply use a
* data-first approach and not worry about the node type until a constraint
* violation is encountered.
* <p>
* The given binary content stream is closed by this method.
*
* @param parent parent node
* @param name name of the file
* @param mime media type of the file
* @param data binary content of the file
* @param date date of last modification
* @return the child node
* @throws RepositoryException if the child node can not be created
* or updated
*/
public static Node putFile(
Node parent, String name, String mime,
InputStream data, Calendar date) throws RepositoryException {
Binary binary = parent.getSession().getValueFactory().createBinary(data);
try {
Node file = getOrAddNode(parent, name, NodeType.NT_FILE);
Node content = getOrAddNode(file, Node.JCR_CONTENT, NodeType.NT_RESOURCE);
content.setProperty(Property.JCR_MIMETYPE, mime);
String[] parameters = mime.split(";");
for (int i = 1; i < parameters.length; i++) {
int equals = parameters[i].indexOf('=');
if (equals != -1) {
String parameter = parameters[i].substring(0, equals);
if ("charset".equalsIgnoreCase(parameter.trim())) {
content.setProperty(
Property.JCR_ENCODING,
parameters[i].substring(equals + 1).trim());
}
}
}
content.setProperty(Property.JCR_LAST_MODIFIED, date);
content.setProperty(Property.JCR_DATA, binary);
return file;
} finally {
binary.dispose();
}
}
/**
* Returns a stream for reading the contents of the file stored at the
* given node. This method works with both on nt:file and nt:resource and
* on any other similar node types, as it only looks for the jcr:data
* property or a jcr:content child node.
* <p>
* The returned stream contains a reference to the underlying
* {@link Binary} value instance that will be disposed when the stream
* is closed. It is the responsibility of the caller to close the stream
* once it is no longer needed.
*
* @since Apache Jackrabbit 2.3
* @param node node to be read
* @return stream for reading the file contents
* @throws RepositoryException if the file can not be accessed
*/
public static InputStream readFile(Node node) throws RepositoryException {
if (node.hasProperty(Property.JCR_DATA)) {
Property data = node.getProperty(Property.JCR_DATA);
final Binary binary = data.getBinary();
return new FilterInputStream(binary.getStream()) {
@Override
public void close() throws IOException {
super.close();
binary.dispose();
}
};
} else if (node.hasNode(Node.JCR_CONTENT)) {
return readFile(node.getNode(Node.JCR_CONTENT));
} else {
throw new RepositoryException(
"Unable to read file node: " + node.getPath());
}
}
/**
* Writes the contents of file stored at the given node to the given
* stream. Similar file handling logic is used as in the
* {@link #readFile(Node)} method.
*
* @since Apache Jackrabbit 2.3
* @param node node to be read
* @param output to which the file contents are written
* @throws RepositoryException if the file can not be accessed
* @throws IOException if the file can not be read or written
*/
public static void readFile(Node node, OutputStream output)
throws RepositoryException, IOException {
InputStream input = readFile(node);
try {
byte[] buffer = new byte[16 * 1024];
int n = input.read(buffer);
while (n != -1) {
output.write(buffer, 0, n);
n = input.read(buffer);
}
} finally {
input.close();
}
}
/**
* Returns the last modified date of the given file node. The value is
* read from the jcr:lastModified property of this node or alternatively
* from a jcr:content child node.
*
* @since Apache Jackrabbit 2.3
* @param node file node
* @return last modified date, or <code>null</code> if not available
* @throws RepositoryException if the last modified date can not be accessed
*/
public static Calendar getLastModified(Node node) throws RepositoryException {
if (node.hasProperty(Property.JCR_LAST_MODIFIED)) {
return node.getProperty(Property.JCR_LAST_MODIFIED).getDate();
} else if (node.hasNode(Node.JCR_CONTENT)) {
return getLastModified(node.getNode(Node.JCR_CONTENT));
} else {
return null;
}
}
/**
* Sets the last modified date of the given file node. The value is
* written to the jcr:lastModified property of a jcr:content child node
* or this node if such a child does not exist.
*
* @since Apache Jackrabbit 2.3
* @param node file node
* @param date modified date
* @throws RepositoryException if the last modified date can not be set
*/
public static void setLastModified(Node node, Calendar date) throws RepositoryException {
if (node.hasNode(Node.JCR_CONTENT)) {
setLastModified(node.getNode(Node.JCR_CONTENT), date);
} else {
node.setProperty(Property.JCR_LAST_MODIFIED, date);
}
}
/**
* Returns a string representation of the given item. The returned string
* is designed to be easily readable while providing maximum amount of
* information for logging and debugging purposes.
* <p>
* The returned string is not meant to be parsed and the exact contents
* can change in future releases. The current string representation of
* a node is "/path/to/node [type]" and the representation of a property is
* "@name = value(s)". Binary values are expressed like "<123 bytes>"
* and other values as their standard binary representation. Multi-valued
* properties have their values listed in like "[ v1, v2, v3, ... ]". No
* more than the three first values are included. Long string values are
* truncated.
*
* @param item given node or property
* @return string representation of the given item
*/
public static String toString(Item item) {
StringBuilder builder = new StringBuilder();
try {
if (item.isNode()) {
builder.append(item.getPath());
builder.append(" [");
builder.append(((Node) item).getPrimaryNodeType().getName());
builder.append("]");
} else {
builder.append("@");
builder.append(item.getName());
builder.append(" = ");
Property property = (Property) item;
if (property.isMultiple()) {
builder.append("[ ");
Value[] values = property.getValues();
for (int i = 0; i < values.length && i < 3; i++) {
if (i > 0) {
builder.append(", ");
}
append(builder, values[i]);
}
if (values.length >= 3) {
builder.append(", ...");
}
builder.append(" ]");
} else {
append(builder, property.getValue());
}
}
} catch (RepositoryException e) {
builder.append("!!! ");
builder.append(e.getMessage());
builder.append(" !!!");
}
return builder.toString();
}
/**
* Private helper method that adds the string representation of the given
* value to the given {@link StringBuilder}. Used by the
* {{@link #toString(Item)} method.
*/
private static void append(StringBuilder builder, Value value)
throws RepositoryException {
if (value.getType() == PropertyType.BINARY) {
Binary binary = value.getBinary();
try {
builder.append("<");
builder.append(binary.getSize());
builder.append(" bytes>");
} finally {
binary.dispose();
}
} else {
String string = value.getString();
if (string.length() > 40) {
builder.append(string.substring(0, 37));
builder.append("...");
} else {
builder.append(string);
}
}
}
private static final List<String> PROPERTY_TYPES_NAMES = new ArrayList<String>();
private static final Map<String, Integer> PROPERTY_TYPES = new HashMap<String, Integer>();
static {
for (int i = PropertyType.UNDEFINED; i <= PropertyType.DECIMAL; i++) {
String typeName = PropertyType.nameFromValue(i);
PROPERTY_TYPES_NAMES.add(typeName);
PROPERTY_TYPES.put(typeName.toLowerCase(), i);
}
}
/**
* Returns the numeric constant value of the property type with
* the specified name. This method is like
* {@link PropertyType#valueFromName(String)}, but the name lookup
* is case insensitive.
*
* @since Apache Jackrabbit 2.3
* @param name name of the property type (case insensitive)
* @return property type constant
* @throws IllegalArgumentException if the given name is not a valid
* property type name
*/
public static int getPropertyType(String name)
throws IllegalArgumentException {
Integer type = PROPERTY_TYPES.get(name.toLowerCase());
if (type != null) {
return type;
} else {
throw new IllegalArgumentException("Unknown property type: " + name);
}
}
/**
* Return the property type names including or excluding 'undefined' depending
* on the specified flag.
*
* @param includeUndefined If true the returned array will contain the name
* of the 'undefined' property type.
* @return array of property type names.
*/
public static String[] getPropertyTypeNames(boolean includeUndefined) {
if (includeUndefined) {
return PROPERTY_TYPES_NAMES.toArray(new String[PROPERTY_TYPES_NAMES.size()]);
} else {
String[] typeNames = new String[PROPERTY_TYPES_NAMES.size()-1];
int i = 0;
for (String name : PROPERTY_TYPES_NAMES) {
if (!PropertyType.TYPENAME_UNDEFINED.equals(name)) {
typeNames[i++] = name;
}
}
return typeNames;
}
}
/**
* Creates or gets the {@link javax.jcr.Node Node} at the given Path.
* In case it has to create the Node all non-existent intermediate path-elements
* will be created with the given NodeType.
*
* <p>
* Changes made are not saved by this method, so <code>session.save()</code>
* has to be called to persist them.
*
* @param absolutePath absolute path to create
* @param nodeType to use for creation of nodes If <code>null</code> the node type
* is determined by the child node definitions of the parent node.
* @param session to use
* @return the Node at path
* @throws RepositoryException in case of exception accessing the Repository
*/
public static Node getOrCreateByPath(String absolutePath, String nodeType, Session session)
throws RepositoryException {
return getOrCreateByPath(absolutePath, false, nodeType, nodeType, session, false);
}
/**
* Creates or gets the {@link javax.jcr.Node Node} at the given Path.
* In case it has to create the Node all non-existent intermediate path-elements
* will be created with the given intermediate node type and the returned node
* will be created with the given nodeType.
*
* @param absolutePath absolute path to create
* @param intermediateNodeType to use for creation of intermediate nodes. If <code>null</code> the node type
* is determined by the child node definitions of the parent node.
* @param nodeType to use for creation of the final node. If <code>null</code> the node type
* is determined by the child node definitions of the parent node.
* @param session to use
* @param autoSave Should save be called when a new node is created?
* @return the Node at absolutePath
* @throws RepositoryException in case of exception accessing the Repository
*/
public static Node getOrCreateByPath(String absolutePath,
String intermediateNodeType,
String nodeType, Session session,
boolean autoSave)
throws RepositoryException {
return getOrCreateByPath(absolutePath, false, intermediateNodeType, nodeType, session, autoSave);
}
/**
* Creates a {@link javax.jcr.Node Node} at the given Path. In case it has
* to create the Node all non-existent intermediate path-elements will be
* created with the given intermediate node type and the returned node will
* be created with the given nodeType.
*
* <p>
* If the path points to an existing node, the leaf node name will be
* regarded as a name hint and a unique node name will be created by
* appending a number to the given name (eg. <code>/some/path/foobar2</code>).
* Please note that <b>the uniqueness check is not an atomic JCR operation</b>,
* so it is possible that you get a {@link RepositoryException} (path
* already exists) if another concurrent session created the same node in
* the meantime.
*
* <p>
* Changes made are not saved by this method, so <code>session.save()</code>
* has to be called to persist them.
*
* @param pathHint
* path to create
* @param nodeType
* to use for creation of nodes. . If <code>null</code> the node type
* is determined by the child node definitions of the parent node.
* @param session
* to use
* @return the newly created Node
* @throws RepositoryException
* in case of exception accessing the Repository
*/
public static Node getOrCreateUniqueByPath(String pathHint, String nodeType, Session session)
throws RepositoryException {
return getOrCreateByPath(pathHint, true, nodeType, nodeType, session, false);
}
/**
* Creates or gets the {@link javax.jcr.Node Node} at the given Path. In
* case it has to create the Node all non-existent intermediate
* path-elements will be created with the given intermediate node type and
* the returned node will be created with the given nodeType.
*
* <p>
* If the parameter <code>createUniqueLeaf</code> is set, it will not get
* an existing node but rather try to create a unique node by appending a
* number to the last path element (leaf node). Please note that <b>the
* uniqueness check is not an atomic JCR operation</b>, so it is possible
* that you get a {@link RepositoryException} (path already exists) if
* another concurrent session created the same node in the meantime.
*
* @param absolutePath
* absolute path to create
* @param createUniqueLeaf
* whether the leaf of the path should be regarded as a name hint
* and a unique node name should be created by appending a number
* to the given name (eg. <code>/some/path/foobar2</code>)
* @param intermediateNodeType
* to use for creation of intermediate nodes. If <code>null</code> the node type
* is determined by the child node definitions of the parent node.
* @param nodeType
* to use for creation of the final node. If <code>null</code> the node type
* is determined by the child node definitions of the parent node.
* @param session
* to use
* @param autoSave
* Should save be called when a new node is created?
* @return the Node at absolutePath
* @throws RepositoryException
* in case of exception accessing the Repository
*/
public static Node getOrCreateByPath(String absolutePath,
boolean createUniqueLeaf,
String intermediateNodeType,
String nodeType, Session session,
boolean autoSave)
throws RepositoryException {
if (absolutePath == null || absolutePath.length() == 0 || "/".equals(absolutePath)) {
// path denotes root node
return session.getRootNode();
}
// create path relative to the root node
return getOrCreateByPath(session.getRootNode(), absolutePath.substring(1),
createUniqueLeaf, intermediateNodeType, nodeType, autoSave);
}
/**
* Creates or gets the {@link javax.jcr.Node node} at the given path. In
* case it has to create the node, nodes for all non-existent intermediate
* path-elements will be created with the given intermediate node type and
* the returned node will be created with the given nodeType.
* <b>Note</b>: When the given path contains parent elements this method might
* create multiple nodes at leaf position (e.g "a/../b" will create the
* child nodes "a" and "b" on the current node).
*
* <p>
* If the node name points to an existing node, the node name will be
* regarded as a name hint and a unique node name will be created by
* appending a number to the given name (eg. <code>/some/path/foobar2</code>).
* Please note that <b>the uniqueness check is not an atomic JCR operation</b>,
* so it is possible that you get a {@link RepositoryException} (path
* already exists) if another concurrent session created the same node in
* the meantime.
*
* <p>
* Changes made are not saved by this method, so <code>session.save()</code>
* has to be called to persist them.
*
* @param parent
* existing parent node for the new node
* @param nodeNameHint
* name hint for the new node
* @param nodeType
* to use for creation of the node. If <code>null</code> the node type
* is determined by the child node definitions of the parent node.
* @return the newly created Node
* @throws RepositoryException
* in case of exception accessing the Repository
*/
public static Node getOrCreateUniqueByPath(Node parent,
String nodeNameHint,
String nodeType)
throws RepositoryException {
return getOrCreateByPath(parent, nodeNameHint, true, nodeType, nodeType, false);
}
/**
* Creates or gets the {@link javax.jcr.Node node} at the given path
* relative to the baseNode. In case it has to create the node, nodes for
* all non-existent intermediate path-elements will be created with the given
* intermediate node type and the returned node will be created with the
* given nodeType. <b>Note</b>: When the given path contains parent elements
* this method might create multiple nodes at leaf position (e.g "a/../b"
* will create the child nodes "a" and "b" on the current node).
* <p>
* If the parameter <code>createUniqueLeaf</code> is set, it will not get
* an existing node but rather try to create a unique node by appending a
* number to the last path element (leaf node). Please note that <b>the
* uniqueness check is not an atomic JCR operation</b>, so it is possible
* that you get a {@link RepositoryException} (path already exists) if
* another concurrent session created the same node in the meantime.
*
* @param baseNode
* existing node that should be the base for the relative path
* @param path
* relative path to create
* @param createUniqueLeaf
* whether the leaf of the path should be regarded as a name hint
* and a unique node name should be created by appending a number
* to the given name (eg. <code>/some/path/foobar2</code>)
* @param intermediateNodeType
* to use for creation of intermediate nodes. If <code>null</code> the node type
* is determined by the child node definitions of the parent node.
* @param nodeType
* to use for creation of the final node. If <code>null</code> the node type
* is determined by the child node definitions of the parent node.
* @param autoSave
* Should save be called when a new node is created?
* @return the Node at path
* @throws RepositoryException
* in case of exception accessing the Repository
*/
public static Node getOrCreateByPath(Node baseNode,
String path,
boolean createUniqueLeaf,
String intermediateNodeType,
String nodeType,
boolean autoSave)
throws RepositoryException {
if (!createUniqueLeaf && baseNode.hasNode(path)) {
// node at path already exists, quicker way
return baseNode.getNode(path);
}
Node node = baseNode;
int pos = path.lastIndexOf('/');
// intermediate path elements
if (pos != -1) {
final StringTokenizer st = new StringTokenizer(path.substring(0, pos), "/");
while (st.hasMoreTokens()) {
final String token = st.nextToken();
if (!node.hasNode(token)) {
try {
if (intermediateNodeType != null) {
node.addNode(token, intermediateNodeType);
} else {
node.addNode(token);
}
if (autoSave) {
node.getSession().save();
}
} catch (RepositoryException e) {
// we ignore this as this folder might be created from a different task
node.refresh(false);
}
}
node = node.getNode(token);
}
path = path.substring(pos + 1);
}
// last path element (path = leaf node name)
if (!node.hasNode(path)) {
if (nodeType != null) {
node.addNode(path, nodeType);
} else {
node.addNode(path);
}
if (autoSave) {
node.getSession().save();
}
} else if (createUniqueLeaf) {
// leaf node already exists, create new unique name
String leafNodeName;
int i = 0;
do {
leafNodeName = path + String.valueOf(i);
i++;
} while (node.hasNode(leafNodeName));
Node leaf;
if (nodeType != null) {
leaf = node.addNode(leafNodeName, nodeType);
} else {
leaf = node.addNode(leafNodeName);
}
if (autoSave) {
node.getSession().save();
}
return leaf;
}
return node.getNode(path);
}
/**
* Get the node at <code>relPath</code> from <code>baseNode</code> or <code>null</code> if no such node exists.
*
* @param baseNode existing node that should be the base for the relative path
* @param relPath relative path to the node to get
* @return the node at <code>relPath</code> from <code>baseNode</code> or <code>null</code> if no such node exists.
* @throws RepositoryException in case of exception accessing the Repository
*/
public static Node getNodeIfExists(Node baseNode, String relPath) throws RepositoryException {
try {
return baseNode.getNode(relPath);
} catch (PathNotFoundException e) {
return null;
}
}
/**
* Gets the node at <code>absPath</code> or <code>null</code> if no such node exists.
*
* @param absPath the absolute path to the node to return
* @param session to use
* @return the node at <code>absPath</code> or <code>null</code> if no such node exists.
* @throws RepositoryException in case of exception accessing the Repository
*/
public static Node getNodeIfExists(String absPath, Session session) throws RepositoryException {
try {
return session.getNode(absPath);
} catch (PathNotFoundException e) {
return null;
}
}
/**
* Returns the string property value at <code>relPath</code> from <code>baseNode</code> or <code>defaultValue</code>
* if no such property exists.
*
* @param baseNode existing node that should be the base for the relative path
* @param relPath relative path to the property to get
* @param defaultValue default value to return when the property does not exist
* @return the string property value at <code>relPath</code> from <code>baseNode</code> or <code>defaultValue</code>
* if no such property exists
* @throws RepositoryException in case of exception accessing the Repository
*/
public static String getStringProperty(Node baseNode, String relPath, String defaultValue) throws RepositoryException {
try {
return baseNode.getProperty(relPath).getString();
} catch (PathNotFoundException e) {
return defaultValue;
}
}
/**
* Returns the long property value at <code>relPath</code> from <code>baseNode</code> or <code>defaultValue</code>
* if no such property exists.
*
* @param baseNode existing node that should be the base for the relative path
* @param relPath relative path to the property to get
* @param defaultValue default value to return when the property does not exist
* @return the long property value at <code>relPath</code> from <code>baseNode</code> or <code>defaultValue</code>
* if no such property exists
* @throws RepositoryException in case of exception accessing the Repository
*/
public static long getLongProperty(Node baseNode, String relPath, long defaultValue) throws RepositoryException {
try {
return baseNode.getProperty(relPath).getLong();
} catch (PathNotFoundException e) {
return defaultValue;
}
}
/**
* Returns the double property value at <code>relPath</code> from <code>baseNode</code> or <code>defaultValue</code>
* if no such property exists.
*
* @param baseNode existing node that should be the base for the relative path
* @param relPath relative path to the property to get
* @param defaultValue default value to return when the property does not exist
* @return the double property value at <code>relPath</code> from <code>baseNode</code> or <code>defaultValue</code>
* if no such property exists
* @throws RepositoryException in case of exception accessing the Repository
*/
public static double getDoubleProperty(Node baseNode, String relPath, double defaultValue) throws RepositoryException {
try {
return baseNode.getProperty(relPath).getDouble();
} catch (PathNotFoundException e) {
return defaultValue;
}
}
/**
* Returns the boolean property value at <code>relPath</code> from <code>baseNode</code> or <code>defaultValue</code>
* if no such property exists.
*
* @param baseNode existing node that should be the base for the relative path
* @param relPath relative path to the property to get
* @param defaultValue default value to return when the property does not exist
* @return the boolean property value at <code>relPath</code> from <code>baseNode</code> or <code>defaultValue</code>
* if no such property exists
* @throws RepositoryException in case of exception accessing the Repository
*/
public static boolean getBooleanProperty(Node baseNode, String relPath, boolean defaultValue) throws RepositoryException {
try {
return baseNode.getProperty(relPath).getBoolean();
} catch (PathNotFoundException e) {
return defaultValue;
}
}
/**
* Returns the date property value at <code>relPath</code> from <code>baseNode</code> or <code>defaultValue</code>
* if no such property exists.
*
* @param baseNode existing node that should be the base for the relative path
* @param relPath relative path to the property to get
* @param defaultValue default value to return when the property does not exist
* @return the date property value at <code>relPath</code> from <code>baseNode</code> or <code>defaultValue</code>
* if no such property exists
* @throws RepositoryException in case of exception accessing the Repository
*/
public static Calendar getDateProperty(Node baseNode, String relPath, Calendar defaultValue) throws RepositoryException {
try {
return baseNode.getProperty(relPath).getDate();
} catch (PathNotFoundException e) {
return defaultValue;
}
}
/**
* Returns the decimal property value at <code>relPath</code> from <code>baseNode</code> or <code>defaultValue</code>
* if no such property exists.
*
* @param baseNode existing node that should be the base for the relative path
* @param relPath relative path to the property to get
* @param defaultValue default value to return when the property does not exist
* @return the decimal property value at <code>relPath</code> from <code>baseNode</code> or <code>defaultValue</code>
* if no such property exists
* @throws RepositoryException in case of exception accessing the Repository
*/
public static BigDecimal getDecimalProperty(Node baseNode, String relPath, BigDecimal defaultValue) throws RepositoryException {
try {
return baseNode.getProperty(relPath).getDecimal();
} catch (PathNotFoundException e) {
return defaultValue;
}
}
/**
* Returns the binary property value at <code>relPath</code> from <code>baseNode</code> or <code>defaultValue</code>
* if no such property exists.
*
* @param baseNode existing node that should be the base for the relative path
* @param relPath relative path to the property to get
* @param defaultValue default value to return when the property does not exist
* @return the binary property value at <code>relPath</code> from <code>baseNode</code> or <code>defaultValue</code>
* if no such property exists
* @throws RepositoryException in case of exception accessing the Repository
*/
public static Binary getBinaryProperty(Node baseNode, String relPath, Binary defaultValue) throws RepositoryException {
try {
return baseNode.getProperty(relPath).getBinary();
} catch (PathNotFoundException e) {
return defaultValue;
}
}
/**
* Returns the string property value at <code>absPath</code> or <code>defaultValue</code>
* if no such property exists.
*
* @param session to use
* @param absPath absolute path to the property to get
* @param defaultValue default value to return when the property does not exist
* @return the string property value at <code>absPath</code> or <code>defaultValue</code>
* if no such property exists
* @throws RepositoryException in case of exception accessing the Repository
*/
public static String getStringProperty(Session session, String absPath, String defaultValue) throws RepositoryException {
try {
return session.getProperty(absPath).getString();
} catch (PathNotFoundException e) {
return defaultValue;
}
}
/**
* Returns the long property value at <code>absPath</code> or <code>defaultValue</code>
* if no such property exists.
*
* @param session to use
* @param absPath absolute path to the property to get
* @param defaultValue default value to return when the property does not exist
* @return the long property value at <code>absPath</code> or <code>defaultValue</code>
* if no such property exists
* @throws RepositoryException in case of exception accessing the Repository
*/
public static long getLongProperty(Session session, String absPath, long defaultValue) throws RepositoryException {
try {
return session.getProperty(absPath).getLong();
} catch (PathNotFoundException e) {
return defaultValue;
}
}
/**
* Returns the double property value at <code>absPath</code> or <code>defaultValue</code>
* if no such property exists.
*
* @param session to use
* @param absPath absolute path to the property to get
* @param defaultValue default value to return when the property does not exist
* @return the double property value at <code>absPath</code> or <code>defaultValue</code>
* if no such property exists
* @throws RepositoryException in case of exception accessing the Repository
*/
public static double getDoubleProperty(Session session, String absPath, double defaultValue) throws RepositoryException {
try {
return session.getProperty(absPath).getDouble();
} catch (PathNotFoundException e) {
return defaultValue;
}
}
/**
* Returns the boolean property value at <code>absPath</code> or <code>defaultValue</code>
* if no such property exists.
*
* @param session to use
* @param absPath absolute path to the property to get
* @param defaultValue default value to return when the property does not exist
* @return the boolean property value at <code>absPath</code> or <code>defaultValue</code>
* if no such property exists
* @throws RepositoryException in case of exception accessing the Repository
*/
public static boolean getBooleanProperty(Session session, String absPath, boolean defaultValue) throws RepositoryException {
try {
return session.getProperty(absPath).getBoolean();
} catch (PathNotFoundException e) {
return defaultValue;
}
}
/**
* Returns the date property value at <code>absPath</code> or <code>defaultValue</code>
* if no such property exists.
*
* @param session to use
* @param absPath absolute path to the property to get
* @param defaultValue default value to return when the property does not exist
* @return the date property value at <code>absPath</code> or <code>defaultValue</code>
* if no such property exists
* @throws RepositoryException in case of exception accessing the Repository
*/
public static Calendar getDateProperty(Session session, String absPath, Calendar defaultValue) throws RepositoryException {
try {
return session.getProperty(absPath).getDate();
} catch (PathNotFoundException e) {
return defaultValue;
}
}
/**
* Returns the decimal property value at <code>absPath</code> or <code>defaultValue</code>
* if no such property exists.
*
* @param session to use
* @param absPath absolute path to the property to get
* @param defaultValue default value to return when the property does not exist
* @return the decimal property value at <code>absPath</code> or <code>defaultValue</code>
* if no such property exists
* @throws RepositoryException in case of exception accessing the Repository
*/
public static BigDecimal getDecimalProperty(Session session, String absPath, BigDecimal defaultValue) throws RepositoryException {
try {
return session.getProperty(absPath).getDecimal();
} catch (PathNotFoundException e) {
return defaultValue;
}
}
/**
* Returns the binary property value at <code>absPath</code> or <code>defaultValue</code>
* if no such property exists.
*
* @param session to use
* @param absPath absolute path to the property to get
* @param defaultValue default value to return when the property does not exist
* @return the binary property value at <code>absPath</code> or <code>defaultValue</code>
* if no such property exists
* @throws RepositoryException in case of exception accessing the Repository
*/
public static Binary getBinaryProperty(Session session, String absPath, Binary defaultValue) throws RepositoryException {
try {
return session.getProperty(absPath).getBinary();
} catch (PathNotFoundException e) {
return defaultValue;
}
}
}