[dna-commits] DNA SVN: r235 - in trunk: dna-maven-classloader/src/main/java/org/jboss/dna/maven and 4 other directories.
dna-commits at lists.jboss.org
dna-commits at lists.jboss.org
Tue Jun 3 13:32:57 EDT 2008
Author: rhauch
Date: 2008-06-03 13:32:57 -0400 (Tue, 03 Jun 2008)
New Revision: 235
Added:
trunk/dna-common/src/main/java/org/jboss/dna/common/text/TextDecoder.java
Modified:
trunk/dna-common/src/main/java/org/jboss/dna/common/text/Jsr283Encoder.java
trunk/dna-common/src/main/java/org/jboss/dna/common/text/NoOpEncoder.java
trunk/dna-common/src/main/java/org/jboss/dna/common/text/TextEncoder.java
trunk/dna-common/src/main/java/org/jboss/dna/common/text/UrlEncoder.java
trunk/dna-maven-classloader/src/main/java/org/jboss/dna/maven/MavenUrl.java
trunk/dna-maven-classloader/src/main/java/org/jboss/dna/maven/spi/JcrMavenUrlProvider.java
trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/NameFactory.java
trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/Path.java
trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/PathFactory.java
trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/ValueComparators.java
trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/ValueFactory.java
trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/AbstractValueFactory.java
trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/BooleanValueFactory.java
trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/DecimalValueFactory.java
trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/DoubleValueFactory.java
trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/InMemoryBinaryValueFactory.java
trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/JodaDateTimeValueFactory.java
trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/LongValueFactory.java
trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/NameValueFactory.java
trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/ObjectValueFactory.java
trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/PathValueFactory.java
trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/StandardValueFactories.java
trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/StringValueFactory.java
trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/UriValueFactory.java
trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/UuidReferenceValueFactory.java
trunk/dna-spi/src/test/java/org/jboss/dna/spi/graph/impl/AbstractValueFactoryTest.java
trunk/dna-spi/src/test/java/org/jboss/dna/spi/graph/impl/BasicPathSegmentTest.java
trunk/dna-spi/src/test/java/org/jboss/dna/spi/graph/impl/BasicPathTest.java
trunk/dna-spi/src/test/java/org/jboss/dna/spi/graph/impl/BooleanValueFactoryTest.java
trunk/dna-spi/src/test/java/org/jboss/dna/spi/graph/impl/DecimalValueFactoryTest.java
trunk/dna-spi/src/test/java/org/jboss/dna/spi/graph/impl/DoubleValueFactoryTest.java
trunk/dna-spi/src/test/java/org/jboss/dna/spi/graph/impl/InMemoryBinaryValueFactoryTest.java
trunk/dna-spi/src/test/java/org/jboss/dna/spi/graph/impl/JodaDateTimeValueFactoryTest.java
trunk/dna-spi/src/test/java/org/jboss/dna/spi/graph/impl/LongValueFactoryTest.java
trunk/dna-spi/src/test/java/org/jboss/dna/spi/graph/impl/NameValueFactoryTest.java
trunk/dna-spi/src/test/java/org/jboss/dna/spi/graph/impl/PathValueFactoryTest.java
Log:
DNA-82: Break TextEncoder interface into two interfaces: one for encoding and one for decoding
http://jira.jboss.org/jira/browse/DNA-82
Broke into separate interfaces, and changed all uses. Some places did require references to both a TextEncoder and TextDecoder, but most only required a single reference. It also made some of the uses of a decoder more clear (than calling it a "decoder" but having the type be TextEncoder, as it was previously.)
Modified: trunk/dna-common/src/main/java/org/jboss/dna/common/text/Jsr283Encoder.java
===================================================================
--- trunk/dna-common/src/main/java/org/jboss/dna/common/text/Jsr283Encoder.java 2008-06-02 20:19:51 UTC (rev 234)
+++ trunk/dna-common/src/main/java/org/jboss/dna/common/text/Jsr283Encoder.java 2008-06-03 17:32:57 UTC (rev 235)
@@ -57,9 +57,10 @@
* </tr>
* </table>
* </p>
+ *
* @author Randall Hauch
*/
-public class Jsr283Encoder implements TextEncoder {
+public class Jsr283Encoder implements TextEncoder, TextDecoder {
/**
* {@inheritDoc}
Modified: trunk/dna-common/src/main/java/org/jboss/dna/common/text/NoOpEncoder.java
===================================================================
--- trunk/dna-common/src/main/java/org/jboss/dna/common/text/NoOpEncoder.java 2008-06-02 20:19:51 UTC (rev 234)
+++ trunk/dna-common/src/main/java/org/jboss/dna/common/text/NoOpEncoder.java 2008-06-03 17:32:57 UTC (rev 235)
@@ -24,9 +24,10 @@
/**
* An encoder implementation that does nothing. This is useful when a {@link TextEncoder encoder} is optional but the code is
* easier to write when there is always an encoder.
+ *
* @author Randall Hauch
*/
-public class NoOpEncoder implements TextEncoder {
+public class NoOpEncoder implements TextEncoder, TextDecoder {
private static final NoOpEncoder INSTANCE = new NoOpEncoder();
Added: trunk/dna-common/src/main/java/org/jboss/dna/common/text/TextDecoder.java
===================================================================
--- trunk/dna-common/src/main/java/org/jboss/dna/common/text/TextDecoder.java (rev 0)
+++ trunk/dna-common/src/main/java/org/jboss/dna/common/text/TextDecoder.java 2008-06-03 17:32:57 UTC (rev 235)
@@ -0,0 +1,41 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.dna.common.text;
+
+/**
+ * Interface for components that can decode text. This is the counterpart to {@link TextEncoder}.
+ *
+ * @author Randall Hauch
+ * @see TextEncoder
+ */
+public interface TextDecoder {
+
+ /**
+ * Return the decoded version of an encoded string
+ *
+ * @param encodedText the encoded text
+ * @return the unecoded form of the text, or null if the supplied node name is also null
+ * @see TextEncoder#encode(String)
+ */
+ public String decode( String encodedText );
+
+}
Property changes on: trunk/dna-common/src/main/java/org/jboss/dna/common/text/TextDecoder.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Modified: trunk/dna-common/src/main/java/org/jboss/dna/common/text/TextEncoder.java
===================================================================
--- trunk/dna-common/src/main/java/org/jboss/dna/common/text/TextEncoder.java 2008-06-02 20:19:51 UTC (rev 234)
+++ trunk/dna-common/src/main/java/org/jboss/dna/common/text/TextEncoder.java 2008-06-03 17:32:57 UTC (rev 235)
@@ -22,25 +22,20 @@
package org.jboss.dna.common.text;
/**
- * Interface for components that can encode and unencode text.
+ * Interface for components that can encode text. This is the counterpart to {@link TextDecoder}.
+ *
* @author Randall Hauch
+ * @see TextDecoder
*/
public interface TextEncoder {
/**
* Returns the encoded version of a string.
+ *
* @param text the text with characters that are to be encoded.
* @return the text with the characters encoded as required, or null if the supplied text is null
- * @see #decode(String)
+ * @see TextDecoder#decode(String)
*/
public String encode( String text );
- /**
- * Return the decoded version of an encoded string
- * @param encodedText the encoded text
- * @return the unecoded form of the text, or null if the supplied node name is also null
- * @see #encode(String)
- */
- public String decode( String encodedText );
-
}
Modified: trunk/dna-common/src/main/java/org/jboss/dna/common/text/UrlEncoder.java
===================================================================
--- trunk/dna-common/src/main/java/org/jboss/dna/common/text/UrlEncoder.java 2008-06-02 20:19:51 UTC (rev 234)
+++ trunk/dna-common/src/main/java/org/jboss/dna/common/text/UrlEncoder.java 2008-06-03 17:32:57 UTC (rev 235)
@@ -29,9 +29,10 @@
* An encoder useful for converting text to be used within a URL, as defined by Section 2.3 of <a
* href="http://www.ietf.org/rfc/rfc2396.txt">RFC 2396</a>. Note that this class does not encode a complete URL ({@link java.net.URLEncoder}
* and {@link java.net.URLDecoder} should be used for such purposes).
+ *
* @author Randall Hauch
*/
-public class UrlEncoder implements TextEncoder {
+public class UrlEncoder implements TextEncoder, TextDecoder {
/**
* Data characters that are allowed in a URI but do not have a reserved purpose are called unreserved. These include upper and
Modified: trunk/dna-maven-classloader/src/main/java/org/jboss/dna/maven/MavenUrl.java
===================================================================
--- trunk/dna-maven-classloader/src/main/java/org/jboss/dna/maven/MavenUrl.java 2008-06-02 20:19:51 UTC (rev 234)
+++ trunk/dna-maven-classloader/src/main/java/org/jboss/dna/maven/MavenUrl.java 2008-06-03 17:32:57 UTC (rev 235)
@@ -26,11 +26,13 @@
import java.net.URLStreamHandler;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
+import org.jboss.dna.common.text.TextDecoder;
import org.jboss.dna.common.text.TextEncoder;
import org.jboss.dna.common.text.UrlEncoder;
/**
* Wrapper for a URL that uses a format for referencing JCR nodes and content.
+ *
* @author Randall Hauch
*/
public class MavenUrl {
@@ -46,6 +48,7 @@
/**
* Get the host name
+ *
* @return the host name
*/
public String getHostname() {
@@ -62,6 +65,7 @@
/**
* Get the port. This method returns {@link #NO_PORT} if the port has not been specified.
+ *
* @return the port
*/
public int getPort() {
@@ -90,6 +94,7 @@
/**
* Set the name of the workspace.
+ *
* @param workspaceName the name of the workspace
*/
public void setWorkspaceName( String workspaceName ) {
@@ -123,6 +128,7 @@
/**
* Get a URL that corresponds to the information in this object.
+ *
* @param handler the URL stream handler that will be used to handle obtaining an input stream or an output stream on the
* resulting URL
* @param encoder an encoder that will be used to escape any characters that are not allowed in URLs; {@link UrlEncoder} will
@@ -196,11 +202,13 @@
* <li><b>path/to/node</b> is the path of the node or property that is to be referenced</li>
* </ul>
* </p>
+ *
* @param url the URL to be parsed
* @param decoder the text encoder that should be used to decode the URL; may be null if no decoding should be done
* @return the object representing the JCR information contained in the URL
+ * @see #parse(URL, TextDecoder)
*/
- public static MavenUrl parse( String url, TextEncoder decoder ) {
+ public static MavenUrl parse( String url, TextDecoder decoder ) {
if (decoder == null) decoder = new UrlEncoder();
// This regular expression has the following groups:
// 1) //hostname:port
@@ -231,12 +239,13 @@
/**
* Parse the supplied URL and determine if the URL fits the JCR URL format. If it does, return a {@link MavenUrl} instance;
* otherwise return null. If the URL is malformed or otherwise invalid, this method also returns null.
+ *
* @param url the URL to be parsed
* @param decoder the text encoder that should be used to decode the URL; may be null if no decoding should be done
* @return the object representing the JCR information contained in the URL
- * @see #parse(String,TextEncoder)
+ * @see #parse(String,TextDecoder)
*/
- public static MavenUrl parse( URL url, TextEncoder decoder ) {
+ public static MavenUrl parse( URL url, TextDecoder decoder ) {
if (url == null) return null;
return parse(url.toExternalForm(), decoder);
}
Modified: trunk/dna-maven-classloader/src/main/java/org/jboss/dna/maven/spi/JcrMavenUrlProvider.java
===================================================================
--- trunk/dna-maven-classloader/src/main/java/org/jboss/dna/maven/spi/JcrMavenUrlProvider.java 2008-06-02 20:19:51 UTC (rev 234)
+++ trunk/dna-maven-classloader/src/main/java/org/jboss/dna/maven/spi/JcrMavenUrlProvider.java 2008-06-03 17:32:57 UTC (rev 235)
@@ -52,6 +52,7 @@
import javax.jcr.nodetype.ConstraintViolationException;
import javax.jcr.nodetype.NoSuchNodeTypeException;
import javax.jcr.version.VersionException;
+import org.jboss.dna.common.text.TextDecoder;
import org.jboss.dna.common.text.TextEncoder;
import org.jboss.dna.common.text.UrlEncoder;
import org.jboss.dna.common.util.Logger;
@@ -96,7 +97,8 @@
public static final String CONTENT_PROPERTY_NAME = "jcr:data";
private final URLStreamHandler urlStreamHandler = new JcrUrlStreamHandler();
- private final TextEncoder urlEncoder = new UrlEncoder().setSlashEncoded(false);
+ private final TextEncoder urlEncoder;
+ private final TextDecoder urlDecoder;
private Repository repository;
private String workspaceName;
private Credentials credentials;
@@ -104,6 +106,15 @@
private final Logger logger = Logger.getLogger(JcrMavenUrlProvider.class);
/**
+ *
+ */
+ public JcrMavenUrlProvider() {
+ UrlEncoder encoder = new UrlEncoder().setSlashEncoded(false);
+ this.urlEncoder = encoder;
+ this.urlDecoder = encoder;
+ }
+
+ /**
* {@inheritDoc}
*/
@Override
@@ -163,6 +174,7 @@
/**
* Get the JCR repository used by this provider
+ *
* @return the repository instance
*/
public Repository getRepository() {
@@ -267,6 +279,7 @@
/**
* Get the JRC path to the node in this repository and it's workspace that represents the artifact with the given type in the
* supplied Maven project.
+ *
* @param mavenId the ID of the Maven project; may not be null
* @param artifactType the type of artifact; may be null
* @param signatureType the type of signature; may be null if the signature file is not desired
@@ -302,6 +315,10 @@
return this.urlEncoder;
}
+ protected TextDecoder getUrlDecoder() {
+ return this.urlDecoder;
+ }
+
protected Session createSession() throws LoginException, NoSuchWorkspaceException, RepositoryException {
if (this.workspaceName != null) {
if (this.credentials != null) {
@@ -319,6 +336,7 @@
* Obtain an input stream to the existing content at the location given by the supplied {@link MavenUrl}. The Maven URL
* should have a path that points to the node where the content is stored in the
* {@link #getContentProperty() content property}.
+ *
* @param mavenUrl the Maven URL to the content; may not be null
* @return the input stream to the content, or null if there is no existing content
* @throws IOException
@@ -354,6 +372,7 @@
* Obtain an output stream to the existing content at the location given by the supplied {@link MavenUrl}. The Maven URL
* should have a path that points to the property or to the node where the content is stored in the
* {@link #getContentProperty() content property}.
+ *
* @param mavenUrl the Maven URL to the content; may not be null
* @return the input stream to the content, or null if there is no existing content
* @throws IOException
@@ -513,6 +532,7 @@
/**
* This {@link URLStreamHandler} specialization understands {@link URL URLs} that point to content in the JCR repository used
* by this Maven repository.
+ *
* @author Randall Hauch
*/
protected class JcrUrlStreamHandler extends URLStreamHandler {
@@ -535,6 +555,7 @@
* Each JcrUrlConnection is used to make a single request to read or write the <code>jcr:content</code> property value on
* the {@link javax.jcr.Node node} that corresponds to the given URL. The node must already exist.
* </p>
+ *
* @author Randall Hauch
*/
protected class MavenUrlConnection extends URLConnection {
@@ -548,7 +569,7 @@
*/
protected MavenUrlConnection( URL url ) {
super(url);
- this.mavenUrl = MavenUrl.parse(url, JcrMavenUrlProvider.this.getUrlEncoder());
+ this.mavenUrl = MavenUrl.parse(url, JcrMavenUrlProvider.this.getUrlDecoder());
}
/**
Modified: trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/NameFactory.java
===================================================================
--- trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/NameFactory.java 2008-06-02 20:19:51 UTC (rev 234)
+++ trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/NameFactory.java 2008-06-03 17:32:57 UTC (rev 235)
@@ -21,48 +21,45 @@
*/
package org.jboss.dna.spi.graph;
-import org.jboss.dna.common.text.TextEncoder;
+import org.jboss.dna.common.text.TextDecoder;
/**
* A factory for creating {@link Name names}.
- *
+ *
* @author Randall Hauch
*/
public interface NameFactory extends ValueFactory<Name> {
- String JCR_PRIMARY_TYPE = "jcr:primaryType";
+ String JCR_PRIMARY_TYPE = "jcr:primaryType";
- /**
- * Create a name from the given namespace URI and local name.
- * <p>
- * This method is equivalent to calling {@link #create(String, String, TextEncoder)} with a null encoder.
- * </p>
- *
- * @param namespaceUri the namespace URI
- * @param localName the local name
- * @return the new name
- * @throws IllegalArgumentException if the local name is <code>null</code> or empty
- */
- Name create( String namespaceUri,
- String localName );
+ /**
+ * Create a name from the given namespace URI and local name.
+ * <p>
+ * This method is equivalent to calling {@link #create(String, String, TextDecoder)} with a null encoder.
+ * </p>
+ *
+ * @param namespaceUri the namespace URI
+ * @param localName the local name
+ * @return the new name
+ * @throws IllegalArgumentException if the local name is <code>null</code> or empty
+ */
+ Name create( String namespaceUri, String localName );
- /**
- * Create a name from the given namespace URI and local name.
- *
- * @param namespaceUri the namespace URI
- * @param localName the local name
- * @param encoder the encoder that should be used to decode the qualified name
- * @return the new name
- * @throws IllegalArgumentException if the local name is <code>null</code> or empty
- */
- Name create( String namespaceUri,
- String localName,
- TextEncoder encoder );
+ /**
+ * Create a name from the given namespace URI and local name.
+ *
+ * @param namespaceUri the namespace URI
+ * @param localName the local name
+ * @param decoder the decoder that should be used to decode the qualified name
+ * @return the new name
+ * @throws IllegalArgumentException if the local name is <code>null</code> or empty
+ */
+ Name create( String namespaceUri, String localName, TextDecoder decoder );
- /**
- * Get the namespace registry.
- *
- * @return the namespace registry; never <code>null</code>
- */
- NamespaceRegistry getNamespaceRegistry();
+ /**
+ * Get the namespace registry.
+ *
+ * @return the namespace registry; never <code>null</code>
+ */
+ NamespaceRegistry getNamespaceRegistry();
}
Modified: trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/Path.java
===================================================================
--- trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/Path.java 2008-06-02 20:19:51 UTC (rev 234)
+++ trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/Path.java 2008-06-03 17:32:57 UTC (rev 235)
@@ -27,6 +27,7 @@
import net.jcip.annotations.Immutable;
import org.jboss.dna.common.text.Jsr283Encoder;
import org.jboss.dna.common.text.NoOpEncoder;
+import org.jboss.dna.common.text.TextDecoder;
import org.jboss.dna.common.text.TextEncoder;
import org.jboss.dna.common.text.UrlEncoder;
import org.jboss.dna.spi.graph.impl.BasicName;
@@ -73,409 +74,425 @@
@Immutable
public interface Path extends Comparable<Path>, Iterable<Path.Segment>, Serializable {
- /**
- * The text encoder that does nothing.
- */
- public static final TextEncoder NO_OP_ENCODER = new NoOpEncoder();
+ /**
+ * The text encoder that does nothing.
+ */
+ public static final TextEncoder NO_OP_ENCODER = new NoOpEncoder();
- /**
- * The text encoder that encodes and decodes according to JSR-283.
- */
- public static final TextEncoder JSR283_ENCODER = new Jsr283Encoder();
+ /**
+ * The text encoder that encodes according to JSR-283.
+ */
+ public static final TextEncoder JSR283_ENCODER = new Jsr283Encoder();
- /**
- * The text encoder that encodes and decodes text according to the rules of <a href="http://www.ietf.org/rfc/rfc2396.txt">RFC
- * 2396</a>.
- */
- public static final TextEncoder URL_ENCODER = new UrlEncoder().setSlashEncoded(true);
+ /**
+ * The text encoder that encodes text according to the rules of <a href="http://www.ietf.org/rfc/rfc2396.txt">RFC 2396</a>.
+ */
+ public static final TextEncoder URL_ENCODER = new UrlEncoder().setSlashEncoded(true);
- /**
- * The default text encoder to be used when none is otherwise specified. This is currently the
- * {@link #JSR283_ENCODER JSR-283 encoder}.
- */
- public static final TextEncoder DEFAULT_ENCODER = JSR283_ENCODER;
+ /**
+ * The text decoder that does nothing.
+ */
+ public static final TextDecoder NO_OP_DECODER = new NoOpEncoder();
- /**
- * The delimiter character used to separate segments within a path.
- */
- public static final char DELIMITER = '/';
+ /**
+ * The text decoder that decodes according to JSR-283.
+ */
+ public static final TextDecoder JSR283_DECODER = new Jsr283Encoder();
- /**
- * String form of the delimiter used to separate segments within a path.
- */
- public static final String DELIMITER_STR = new String(new char[] {DELIMITER});
+ /**
+ * The text decoder that decodes text according to the rules of <a href="http://www.ietf.org/rfc/rfc2396.txt">RFC 2396</a>.
+ */
+ public static final TextDecoder URL_DECODER = new UrlEncoder().setSlashEncoded(true);
- /**
- * String representation of the segment that references a parent.
- */
- public static final String PARENT = "..";
+ /**
+ * The default text encoder to be used when none is otherwise specified. This is currently the
+ * {@link #JSR283_ENCODER JSR-283 encoder}.
+ */
+ public static final TextEncoder DEFAULT_ENCODER = JSR283_ENCODER;
- /**
- * String representation of the segment that references the same segment.
- */
- public static final String SELF = ".";
+ /**
+ * The default text decoder to be used when none is otherwise specified. This is currently the
+ * {@link #JSR283_ENCODER JSR-283 encoder}.
+ */
+ public static final TextDecoder DEFAULT_DECODER = JSR283_DECODER;
- /**
- * The index that will be returned for a {@link Segment} that {@link Segment#hasIndex() has no index}.
- */
- public static final int NO_INDEX = -1;
+ /**
+ * The delimiter character used to separate segments within a path.
+ */
+ public static final char DELIMITER = '/';
- /**
- * Representation of the segments that occur within a path.
- *
- * @author Randall Hauch
- */
- @Immutable
- public static interface Segment extends Cloneable, Comparable<Segment>, Serializable {
+ /**
+ * String form of the delimiter used to separate segments within a path.
+ */
+ public static final String DELIMITER_STR = new String(new char[] {DELIMITER});
- /**
- * Get the name component of this segment.
- *
- * @return the segment's name
- */
- public Name getName();
+ /**
+ * String representation of the segment that references a parent.
+ */
+ public static final String PARENT = "..";
- /**
- * Get the index for this segment, which will be {@link Path#NO_INDEX 0} if this segment has no specific index.
- *
- * @return the index
- */
- public int getIndex();
+ /**
+ * String representation of the segment that references the same segment.
+ */
+ public static final String SELF = ".";
- /**
- * Return whether this segment has an index.
- *
- * @return true if this segment has an index, or false otherwise.
- */
- public boolean hasIndex();
+ /**
+ * The index that will be returned for a {@link Segment} that {@link Segment#hasIndex() has no index}.
+ */
+ public static final int NO_INDEX = -1;
- /**
- * Return whether this segment is a self-reference.
- *
- * @return true if the segment is a self-reference, or false otherwise.
- */
- public boolean isSelfReference();
+ /**
+ * Representation of the segments that occur within a path.
+ *
+ * @author Randall Hauch
+ */
+ @Immutable
+ public static interface Segment extends Cloneable, Comparable<Segment>, Serializable {
- /**
- * Return whether this segment is a reference to a parent.
- *
- * @return true if the segment is a parent-reference, or false otherwise.
- */
- public boolean isParentReference();
+ /**
+ * Get the name component of this segment.
+ *
+ * @return the segment's name
+ */
+ public Name getName();
- /**
- * Get the string form of the segment. The {@link #DEFAULT_ENCODER default encoder} is used to encode characters in each
- * of the path segments.
- *
- * @return the encoded string
- * @see #getString(TextEncoder)
- */
- public String getString();
+ /**
+ * Get the index for this segment, which will be {@link Path#NO_INDEX 0} if this segment has no specific index.
+ *
+ * @return the index
+ */
+ public int getIndex();
- /**
- * Get the encoded string form of the segment, using the supplied encoder to encode characters in each of the path
- * segments.
- *
- * @param encoder the encoder to use, or null if the {@link #DEFAULT_ENCODER default encoder} should be used
- * @return the encoded string
- * @see #getString()
- */
- public String getString( TextEncoder encoder );
+ /**
+ * Return whether this segment has an index.
+ *
+ * @return true if this segment has an index, or false otherwise.
+ */
+ public boolean hasIndex();
- /**
- * Get the string form of the segment, using the supplied namespace registry to convert the name's namespace URI to a
- * prefix. The {@link #DEFAULT_ENCODER default encoder} is used to encode characters in each of the path segments.
- *
- * @param namespaceRegistry the namespace registry that should be used to obtain the prefix for the
- * {@link Name#getNamespaceUri() namespace URI} in the segment's {@link #getName() name}
- * @return the encoded string
- * @throws IllegalArgumentException if the namespace registry is null
- * @see #getString(NamespaceRegistry,TextEncoder)
- */
- public String getString( NamespaceRegistry namespaceRegistry );
+ /**
+ * Return whether this segment is a self-reference.
+ *
+ * @return true if the segment is a self-reference, or false otherwise.
+ */
+ public boolean isSelfReference();
- /**
- * Get the encoded string form of the segment, using the supplied namespace registry to convert the name's namespace URI
- * to a prefix and the supplied encoder to encode characters in each of the path segments.
- *
- * @param namespaceRegistry the namespace registry that should be used to obtain the prefix for the
- * {@link Name#getNamespaceUri() namespace URI} in the segment's {@link #getName() name}
- * @param encoder the encoder to use, or null if the {@link #DEFAULT_ENCODER default encoder} should be used
- * @return the encoded string
- * @throws IllegalArgumentException if the namespace registry is null
- * @see #getString(NamespaceRegistry)
- */
- public String getString( NamespaceRegistry namespaceRegistry,
- TextEncoder encoder );
- }
+ /**
+ * Return whether this segment is a reference to a parent.
+ *
+ * @return true if the segment is a parent-reference, or false otherwise.
+ */
+ public boolean isParentReference();
- /**
- * Singleton instance of the name referencing a self, provided as a convenience.
- */
- public static final Name SELF_NAME = new BasicName(null, SELF);
+ /**
+ * Get the string form of the segment. The {@link #DEFAULT_ENCODER default encoder} is used to encode characters in each
+ * of the path segments.
+ *
+ * @return the encoded string
+ * @see #getString(TextEncoder)
+ */
+ public String getString();
- /**
- * Singleton instance of the name referencing a parent, provided as a convenience.
- */
- public static final Name PARENT_NAME = new BasicName(null, PARENT);
+ /**
+ * Get the encoded string form of the segment, using the supplied encoder to encode characters in each of the path
+ * segments.
+ *
+ * @param encoder the encoder to use, or null if the {@link #DEFAULT_ENCODER default encoder} should be used
+ * @return the encoded string
+ * @see #getString()
+ */
+ public String getString( TextEncoder encoder );
- /**
- * Singleton instance of the path segment referencing a parent, provided as a convenience.
- */
- public static final Path.Segment SELF_SEGMENT = new BasicPathSegment(SELF_NAME);
+ /**
+ * Get the string form of the segment, using the supplied namespace registry to convert the name's namespace URI to a
+ * prefix. The {@link #DEFAULT_ENCODER default encoder} is used to encode characters in each of the path segments.
+ *
+ * @param namespaceRegistry the namespace registry that should be used to obtain the prefix for the
+ * {@link Name#getNamespaceUri() namespace URI} in the segment's {@link #getName() name}
+ * @return the encoded string
+ * @throws IllegalArgumentException if the namespace registry is null
+ * @see #getString(NamespaceRegistry,TextEncoder)
+ */
+ public String getString( NamespaceRegistry namespaceRegistry );
- /**
- * Singleton instance of the path segment referencing a parent, provided as a convenience.
- */
- public static final Path.Segment PARENT_SEGMENT = new BasicPathSegment(PARENT_NAME);
+ /**
+ * Get the encoded string form of the segment, using the supplied namespace registry to convert the name's namespace URI
+ * to a prefix and the supplied encoder to encode characters in each of the path segments.
+ *
+ * @param namespaceRegistry the namespace registry that should be used to obtain the prefix for the
+ * {@link Name#getNamespaceUri() namespace URI} in the segment's {@link #getName() name}
+ * @param encoder the encoder to use, or null if the {@link #DEFAULT_ENCODER default encoder} should be used
+ * @return the encoded string
+ * @throws IllegalArgumentException if the namespace registry is null
+ * @see #getString(NamespaceRegistry)
+ */
+ public String getString( NamespaceRegistry namespaceRegistry, TextEncoder encoder );
+ }
- /**
- * Return the number of segments in this path.
- *
- * @return the number of path segments
- */
- public int size();
+ /**
+ * Singleton instance of the name referencing a self, provided as a convenience.
+ */
+ public static final Name SELF_NAME = new BasicName(null, SELF);
- /**
- * Return whether this path represents the root path.
- *
- * @return true if this path is the root path, or false otherwise
- */
- public boolean isRoot();
+ /**
+ * Singleton instance of the name referencing a parent, provided as a convenience.
+ */
+ public static final Name PARENT_NAME = new BasicName(null, PARENT);
- /**
- * Determine whether this path represents the same as the supplied path. This is equivalent to calling
- * <code>this.compareTo(other) == 0 </code>.
- *
- * @param other the other path to compare with this path
- * @return true if the paths are equivalent, or false otherwise
- */
- public boolean isSame( Path other );
+ /**
+ * Singleton instance of the path segment referencing a parent, provided as a convenience.
+ */
+ public static final Path.Segment SELF_SEGMENT = new BasicPathSegment(SELF_NAME);
- /**
- * Determine whether this path is an ancestor of the supplied path. A path is considered an ancestor of another path if the
- * the ancestor path appears in its entirety at the beginning of the decendant path, and where the decendant path contains at
- * least one additional segment.
- *
- * @param decendant the path that may be the decendant
- * @return true if this path is an ancestor of the supplied path, or false otherwise
- */
- public boolean isAncestorOf( Path decendant );
+ /**
+ * Singleton instance of the path segment referencing a parent, provided as a convenience.
+ */
+ public static final Path.Segment PARENT_SEGMENT = new BasicPathSegment(PARENT_NAME);
- /**
- * Determine whether this path is an decendant of the supplied path. A path is considered a decendant of another path if the
- * the decendant path starts exactly with the entire ancestor path but contains at least one additional segment.
- *
- * @param ancestor the path that may be the ancestor
- * @return true if this path is an decendant of the supplied path, or false otherwise
- */
- public boolean isDecendantOf( Path ancestor );
+ /**
+ * Return the number of segments in this path.
+ *
+ * @return the number of path segments
+ */
+ public int size();
- /**
- * Return whether this path is an absolute path. A path is either relative or {@link #isAbsolute() absolute}. An absolute
- * path starts with a "/".
- *
- * @return true if the path is absolute, or false otherwise
- */
- public boolean isAbsolute();
+ /**
+ * Return whether this path represents the root path.
+ *
+ * @return true if this path is the root path, or false otherwise
+ */
+ public boolean isRoot();
- /**
- * Return whether this path is normalized and contains no "." segments and as few ".." segments as possible. For example, the
- * path "../a" is normalized, while "/a/b/c/../d" is not normalized.
- *
- * @return true if this path is normalized, or false otherwise
- */
- public boolean isNormalized();
+ /**
+ * Determine whether this path represents the same as the supplied path. This is equivalent to calling
+ * <code>this.compareTo(other) == 0 </code>.
+ *
+ * @param other the other path to compare with this path
+ * @return true if the paths are equivalent, or false otherwise
+ */
+ public boolean isSame( Path other );
- /**
- * Get a normalized path with as many ".." segments and all "." resolved.
- *
- * @return the normalized path, or this object if this path is already normalized
- * @throws InvalidPathException if the normalized form would result in a path with negative length (e.g., "/a/../../..")
- */
- public Path getNormalizedPath();
+ /**
+ * Determine whether this path is an ancestor of the supplied path. A path is considered an ancestor of another path if the
+ * the ancestor path appears in its entirety at the beginning of the decendant path, and where the decendant path contains at
+ * least one additional segment.
+ *
+ * @param decendant the path that may be the decendant
+ * @return true if this path is an ancestor of the supplied path, or false otherwise
+ */
+ public boolean isAncestorOf( Path decendant );
- /**
- * Get the canonical form of this path. A canonical path has is {@link #isAbsolute() absolute} and {@link #isNormalized()}.
- *
- * @return the canonical path, or this object if it is already in its canonical form
- * @throws InvalidPathException if the path is not absolute and cannot be canonicalized
- */
- public Path getCanonicalPath();
+ /**
+ * Determine whether this path is an decendant of the supplied path. A path is considered a decendant of another path if the
+ * the decendant path starts exactly with the entire ancestor path but contains at least one additional segment.
+ *
+ * @param ancestor the path that may be the ancestor
+ * @return true if this path is an decendant of the supplied path, or false otherwise
+ */
+ public boolean isDecendantOf( Path ancestor );
- /**
- * Get a relative path from the supplied path to this path.
- *
- * @param startingPath the path specifying the starting point for the new relative path; may not be null
- * @return the relative path
- * @throws IllegalArgumentException if the supplied path is null
- * @throws PathNotFoundException if both this path and the supplied path are not absolute
- */
- public Path relativeTo( Path startingPath );
+ /**
+ * Return whether this path is an absolute path. A path is either relative or {@link #isAbsolute() absolute}. An absolute
+ * path starts with a "/".
+ *
+ * @return true if the path is absolute, or false otherwise
+ */
+ public boolean isAbsolute();
- /**
- * Get the absolute path by resolving the supplied relative (non-absolute) path against this absolute path.
- *
- * @param relativePath the relative path that is to be resolved against this path
- * @return the absolute and normalized path resolved from this path and the supplied absolute path
- * @throws IllegalArgumentException if the supplied path is null
- * @throws InvalidPathException if the this path is not absolute or if the supplied path is not relative.
- */
- public Path resolve( Path relativePath );
+ /**
+ * Return whether this path is normalized and contains no "." segments and as few ".." segments as possible. For example, the
+ * path "../a" is normalized, while "/a/b/c/../d" is not normalized.
+ *
+ * @return true if this path is normalized, or false otherwise
+ */
+ public boolean isNormalized();
- /**
- * Get the absolute path by resolving this relative (non-absolute) path against the supplied absolute path.
- *
- * @param absolutePath the absolute path to which this relative path should be resolve
- * @return the absolute path resolved from this path and the supplied absolute path
- * @throws IllegalArgumentException if the supplied path is null
- * @throws InvalidPathException if the supplied path is not absolute or if this path is not relative.
- */
- public Path resolveAgainst( Path absolutePath );
+ /**
+ * Get a normalized path with as many ".." segments and all "." resolved.
+ *
+ * @return the normalized path, or this object if this path is already normalized
+ * @throws InvalidPathException if the normalized form would result in a path with negative length (e.g., "/a/../../..")
+ */
+ public Path getNormalizedPath();
- /**
- * Return the path to the parent, or this path if it is the {@link #isRoot() root}. This is an efficient operation that does
- * not require copying any data.
- *
- * @return the parent path, or this path if it is already the root
- */
- public Path getAncestor();
+ /**
+ * Get the canonical form of this path. A canonical path has is {@link #isAbsolute() absolute} and {@link #isNormalized()}.
+ *
+ * @return the canonical path, or this object if it is already in its canonical form
+ * @throws InvalidPathException if the path is not absolute and cannot be canonicalized
+ */
+ public Path getCanonicalPath();
- /**
- * Return the path to the ancestor of the supplied degree. An ancestor of degree <code>x</code> is the path that is
- * <code>x</code> levels up along the path. For example, <code>degree = 0</code> returns this path, while
- * <code>degree = 1</code> returns the parent of this path, <code>degree = 2</code> returns the grandparent of this path,
- * and so on. Note that the result may be unexpected if this path is not {@link #isNormalized() normalized}, as a
- * non-normalized path contains ".." and "." segments.
- *
- * @param degree
- * @return the ancestor of the supplied degree
- * @throws IllegalArgumentException if the degree is negative
- * @throws PathNotFoundException if the degree is greater than the {@link #size() length} of this path
- */
- public Path getAncestor( int degree );
+ /**
+ * Get a relative path from the supplied path to this path.
+ *
+ * @param startingPath the path specifying the starting point for the new relative path; may not be null
+ * @return the relative path
+ * @throws IllegalArgumentException if the supplied path is null
+ * @throws PathNotFoundException if both this path and the supplied path are not absolute
+ */
+ public Path relativeTo( Path startingPath );
- /**
- * Determine whether this path and the supplied path have the same immediate ancestor. In other words, this method determines
- * whether the node represented by this path is a sibling of the node represented by the supplied path.
- *
- * @param that the other path
- * @return true if this path and the supplied path have the same immediate ancestor.
- * @throws IllegalArgumentException if the supplied path is null
- */
- public boolean hasSameAncestor( Path that );
+ /**
+ * Get the absolute path by resolving the supplied relative (non-absolute) path against this absolute path.
+ *
+ * @param relativePath the relative path that is to be resolved against this path
+ * @return the absolute and normalized path resolved from this path and the supplied absolute path
+ * @throws IllegalArgumentException if the supplied path is null
+ * @throws InvalidPathException if the this path is not absolute or if the supplied path is not relative.
+ */
+ public Path resolve( Path relativePath );
- /**
- * Find the lowest common ancestor of this path and the supplied path.
- *
- * @param that the other path
- * @return the lowest common ancestor, which may be the root path if there is no other.
- * @throws IllegalArgumentException if the supplied path is null
- */
- public Path getCommonAncestor( Path that );
+ /**
+ * Get the absolute path by resolving this relative (non-absolute) path against the supplied absolute path.
+ *
+ * @param absolutePath the absolute path to which this relative path should be resolve
+ * @return the absolute path resolved from this path and the supplied absolute path
+ * @throws IllegalArgumentException if the supplied path is null
+ * @throws InvalidPathException if the supplied path is not absolute or if this path is not relative.
+ */
+ public Path resolveAgainst( Path absolutePath );
- /**
- * Get the last segment in this path.
- *
- * @return the last segment, or null if the path is empty
- */
- public Segment getLastSegment();
+ /**
+ * Return the path to the parent, or this path if it is the {@link #isRoot() root}. This is an efficient operation that does
+ * not require copying any data.
+ *
+ * @return the parent path, or this path if it is already the root
+ */
+ public Path getAncestor();
- /**
- * Get the segment at the supplied index.
- *
- * @param index the index
- * @return the segment
- * @throws IndexOutOfBoundsException if the index is out of bounds
- */
- public Segment getSegment( int index );
+ /**
+ * Return the path to the ancestor of the supplied degree. An ancestor of degree <code>x</code> is the path that is
+ * <code>x</code> levels up along the path. For example, <code>degree = 0</code> returns this path, while
+ * <code>degree = 1</code> returns the parent of this path, <code>degree = 2</code> returns the grandparent of this path,
+ * and so on. Note that the result may be unexpected if this path is not {@link #isNormalized() normalized}, as a
+ * non-normalized path contains ".." and "." segments.
+ *
+ * @param degree
+ * @return the ancestor of the supplied degree
+ * @throws IllegalArgumentException if the degree is negative
+ * @throws PathNotFoundException if the degree is greater than the {@link #size() length} of this path
+ */
+ public Path getAncestor( int degree );
- /**
- * Return a new path consisting of the segments starting at <code>beginIndex</code> index (inclusive). This is equivalent to
- * calling <code>path.subpath(beginIndex,path.size()-1)</code>.
- *
- * @param beginIndex the beginning index, inclusive.
- * @return the specified subpath
- * @exception IndexOutOfBoundsException if the <code>beginIndex</code> is negative or larger than the length of this
- * <code>Path</code> object
- */
- public Path subpath( int beginIndex );
+ /**
+ * Determine whether this path and the supplied path have the same immediate ancestor. In other words, this method determines
+ * whether the node represented by this path is a sibling of the node represented by the supplied path.
+ *
+ * @param that the other path
+ * @return true if this path and the supplied path have the same immediate ancestor.
+ * @throws IllegalArgumentException if the supplied path is null
+ */
+ public boolean hasSameAncestor( Path that );
- /**
- * Return a new path consisting of the segments between the <code>beginIndex</code> index (inclusive) and the
- * <code>endIndex</code> index (exclusive).
- *
- * @param beginIndex the beginning index, inclusive.
- * @param endIndex the ending index, exclusive.
- * @return the specified subpath
- * @exception IndexOutOfBoundsException if the <code>beginIndex</code> is negative, or <code>endIndex</code> is larger
- * than the length of this <code>Path</code> object, or <code>beginIndex</code> is larger than
- * <code>endIndex</code>.
- */
- public Path subpath( int beginIndex,
- int endIndex );
+ /**
+ * Find the lowest common ancestor of this path and the supplied path.
+ *
+ * @param that the other path
+ * @return the lowest common ancestor, which may be the root path if there is no other.
+ * @throws IllegalArgumentException if the supplied path is null
+ */
+ public Path getCommonAncestor( Path that );
- /**
- * {@inheritDoc}
- */
- public Iterator<Segment> iterator();
+ /**
+ * Get the last segment in this path.
+ *
+ * @return the last segment, or null if the path is empty
+ */
+ public Segment getLastSegment();
- /**
- * Obtain a copy of the segments in this path. None of the segments are encoded.
- *
- * @return the array of segments as a copy
- */
- public Segment[] getSegmentsArray();
+ /**
+ * Get the segment at the supplied index.
+ *
+ * @param index the index
+ * @return the segment
+ * @throws IndexOutOfBoundsException if the index is out of bounds
+ */
+ public Segment getSegment( int index );
- /**
- * Get an unmodifiable list of the path segments.
- *
- * @return the unmodifiable list of path segments; never null
- */
- public List<Segment> getSegmentsList();
+ /**
+ * Return a new path consisting of the segments starting at <code>beginIndex</code> index (inclusive). This is equivalent to
+ * calling <code>path.subpath(beginIndex,path.size()-1)</code>.
+ *
+ * @param beginIndex the beginning index, inclusive.
+ * @return the specified subpath
+ * @exception IndexOutOfBoundsException if the <code>beginIndex</code> is negative or larger than the length of this
+ * <code>Path</code> object
+ */
+ public Path subpath( int beginIndex );
- /**
- * Get the string form of the path. The {@link #DEFAULT_ENCODER default encoder} is used to encode characters in each of the
- * path segments.
- *
- * @return the encoded string
- * @see #getString(TextEncoder)
- */
- public String getString();
+ /**
+ * Return a new path consisting of the segments between the <code>beginIndex</code> index (inclusive) and the
+ * <code>endIndex</code> index (exclusive).
+ *
+ * @param beginIndex the beginning index, inclusive.
+ * @param endIndex the ending index, exclusive.
+ * @return the specified subpath
+ * @exception IndexOutOfBoundsException if the <code>beginIndex</code> is negative, or <code>endIndex</code> is larger
+ * than the length of this <code>Path</code> object, or <code>beginIndex</code> is larger than <code>endIndex</code>.
+ */
+ public Path subpath( int beginIndex, int endIndex );
- /**
- * Get the encoded string form of the path, using the supplied encoder to encode characters in each of the path segments.
- *
- * @param encoder the encoder to use, or null if the {@link #DEFAULT_ENCODER default encoder} should be used
- * @return the encoded string
- * @see #getString()
- */
- public String getString( TextEncoder encoder );
+ /**
+ * {@inheritDoc}
+ */
+ public Iterator<Segment> iterator();
- /**
- * Get the string form of the path, using the supplied namespace registry to convert the names' namespace URIs to prefixes.
- * The {@link #DEFAULT_ENCODER default encoder} is used to encode characters in each of the path segments.
- *
- * @param namespaceRegistry the namespace registry that should be used to obtain the prefix for the
- * {@link Name#getNamespaceUri() namespace URIs} in the segment {@link Segment#getName() names}
- * @return the encoded string
- * @throws IllegalArgumentException if the namespace registry is null
- * @see #getString(NamespaceRegistry,TextEncoder)
- */
- public String getString( NamespaceRegistry namespaceRegistry );
+ /**
+ * Obtain a copy of the segments in this path. None of the segments are encoded.
+ *
+ * @return the array of segments as a copy
+ */
+ public Segment[] getSegmentsArray();
- /**
- * Get the encoded string form of the path, using the supplied namespace registry to convert the names' namespace URIs to
- * prefixes and the supplied encoder to encode characters in each of the path segments.
- *
- * @param namespaceRegistry the namespace registry that should be used to obtain the prefix for the
- * {@link Name#getNamespaceUri() namespace URIs} in the segment {@link Segment#getName() names}
- * @param encoder the encoder to use, or null if the {@link #DEFAULT_ENCODER default encoder} should be used
- * @return the encoded string
- * @throws IllegalArgumentException if the namespace registry is null
- * @see #getString(NamespaceRegistry)
- */
- public String getString( NamespaceRegistry namespaceRegistry,
- TextEncoder encoder );
+ /**
+ * Get an unmodifiable list of the path segments.
+ *
+ * @return the unmodifiable list of path segments; never null
+ */
+ public List<Segment> getSegmentsList();
+ /**
+ * Get the string form of the path. The {@link #DEFAULT_ENCODER default encoder} is used to encode characters in each of the
+ * path segments.
+ *
+ * @return the encoded string
+ * @see #getString(TextEncoder)
+ */
+ public String getString();
+
+ /**
+ * Get the encoded string form of the path, using the supplied encoder to encode characters in each of the path segments.
+ *
+ * @param encoder the encoder to use, or null if the {@link #DEFAULT_ENCODER default encoder} should be used
+ * @return the encoded string
+ * @see #getString()
+ */
+ public String getString( TextEncoder encoder );
+
+ /**
+ * Get the string form of the path, using the supplied namespace registry to convert the names' namespace URIs to prefixes.
+ * The {@link #DEFAULT_ENCODER default encoder} is used to encode characters in each of the path segments.
+ *
+ * @param namespaceRegistry the namespace registry that should be used to obtain the prefix for the
+ * {@link Name#getNamespaceUri() namespace URIs} in the segment {@link Segment#getName() names}
+ * @return the encoded string
+ * @throws IllegalArgumentException if the namespace registry is null
+ * @see #getString(NamespaceRegistry,TextEncoder)
+ */
+ public String getString( NamespaceRegistry namespaceRegistry );
+
+ /**
+ * Get the encoded string form of the path, using the supplied namespace registry to convert the names' namespace URIs to
+ * prefixes and the supplied encoder to encode characters in each of the path segments.
+ *
+ * @param namespaceRegistry the namespace registry that should be used to obtain the prefix for the
+ * {@link Name#getNamespaceUri() namespace URIs} in the segment {@link Segment#getName() names}
+ * @param encoder the encoder to use, or null if the {@link #DEFAULT_ENCODER default encoder} should be used
+ * @return the encoded string
+ * @throws IllegalArgumentException if the namespace registry is null
+ * @see #getString(NamespaceRegistry)
+ */
+ public String getString( NamespaceRegistry namespaceRegistry, TextEncoder encoder );
+
}
Modified: trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/PathFactory.java
===================================================================
--- trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/PathFactory.java 2008-06-02 20:19:51 UTC (rev 234)
+++ trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/PathFactory.java 2008-06-03 17:32:57 UTC (rev 235)
@@ -21,7 +21,7 @@
*/
package org.jboss.dna.spi.graph;
-import org.jboss.dna.common.text.TextEncoder;
+import org.jboss.dna.common.text.TextDecoder;
/**
* A factory for creating {@link Path paths}. This interface extends the {@link ValueFactory} generic interface and adds specific
@@ -32,148 +32,141 @@
*/
public interface PathFactory extends ValueFactory<Path> {
- /**
- * Create an absolute root path. Subsequent calls will always return the same instance.
- *
- * @return the new path
- */
- Path create();
+ /**
+ * Create an absolute root path. Subsequent calls will always return the same instance.
+ *
+ * @return the new path
+ */
+ Path create();
- /**
- * Create an absolute path with the supplied segment names, in order. If no segments are provided, the result will be the root
- * path.
- *
- * @param segmentNames the names of the segments
- * @return the new path
- * @throws IllegalArgumentException if at least one segment name is provided and if any of the supplied segment names are null
- */
- Path create( Name... segmentNames );
+ /**
+ * Create an absolute path with the supplied segment names, in order. If no segments are provided, the result will be the root
+ * path.
+ *
+ * @param segmentNames the names of the segments
+ * @return the new path
+ * @throws IllegalArgumentException if at least one segment name is provided and if any of the supplied segment names are null
+ */
+ Path create( Name... segmentNames );
- /**
- * Create an absolute path with the supplied segments, in order. If no segments are provided, the result will be the root
- * path.
- *
- * @param segments the segments
- * @return the new path
- * @throws IllegalArgumentException if at least one segment is provided and if any of the supplied segments are null
- */
- Path create( Path.Segment... segments );
+ /**
+ * Create an absolute path with the supplied segments, in order. If no segments are provided, the result will be the root
+ * path.
+ *
+ * @param segments the segments
+ * @return the new path
+ * @throws IllegalArgumentException if at least one segment is provided and if any of the supplied segments are null
+ */
+ Path create( Path.Segment... segments );
- /**
- * Create an empty relative path (i.e., equivalent to {@link #createRelativePath(Path.Segment...) createRelativePath}({@link Path#SELF_SEGMENT})).
- * Subsequent calls will always return the same instance.
- *
- * @return the new path
- */
- Path createRelativePath();
+ /**
+ * Create an empty relative path (i.e., equivalent to {@link #createRelativePath(Path.Segment...) createRelativePath}({@link Path#SELF_SEGMENT})).
+ * Subsequent calls will always return the same instance.
+ *
+ * @return the new path
+ */
+ Path createRelativePath();
- /**
- * Create a relative path with the supplied segment names, in order. If no segments are provided, the result will be the root
- * path.
- *
- * @param segmentNames the names of the segments
- * @return the new path
- * @throws IllegalArgumentException if at least one segment name is provided and if any of the supplied segment names are null
- */
- Path createRelativePath( Name... segmentNames );
+ /**
+ * Create a relative path with the supplied segment names, in order. If no segments are provided, the result will be the root
+ * path.
+ *
+ * @param segmentNames the names of the segments
+ * @return the new path
+ * @throws IllegalArgumentException if at least one segment name is provided and if any of the supplied segment names are null
+ */
+ Path createRelativePath( Name... segmentNames );
- /**
- * Create a relative path with the supplied segments, in order. If no segments are provided, the result will be the root path.
- *
- * @param segments the segments
- * @return the new path
- * @throws IllegalArgumentException if at least one segment is provided and if any of the supplied segments are null
- */
- Path createRelativePath( Path.Segment... segments );
+ /**
+ * Create a relative path with the supplied segments, in order. If no segments are provided, the result will be the root path.
+ *
+ * @param segments the segments
+ * @return the new path
+ * @throws IllegalArgumentException if at least one segment is provided and if any of the supplied segments are null
+ */
+ Path createRelativePath( Path.Segment... segments );
- /**
- * Create a path by appending the supplied names to the parent path.
- *
- * @param parentPath the path that is to provide the basis for the new path
- * @param segmentName the name of the segment to be appended to the parent path
- * @param index the index for the new segment
- * @return the new path
- * @throws IllegalArgumentException if the parent path reference or the segment name is null, or if the index is invalid
- */
- Path create( Path parentPath,
- Name segmentName,
- int index );
+ /**
+ * Create a path by appending the supplied names to the parent path.
+ *
+ * @param parentPath the path that is to provide the basis for the new path
+ * @param segmentName the name of the segment to be appended to the parent path
+ * @param index the index for the new segment
+ * @return the new path
+ * @throws IllegalArgumentException if the parent path reference or the segment name is null, or if the index is invalid
+ */
+ Path create( Path parentPath, Name segmentName, int index );
- /**
- * Create a path by appending the supplied names to the parent path. If no names are appended, the parent path is returned.
- *
- * @param parentPath the path that is to provide the basis for the new path
- * @param segmentNames the names of the segments that are to be appended, in order, to the parent path
- * @return the new path
- * @throws IllegalArgumentException if the parent path reference is null, or if at least one segment name is provided and if
- * any of the supplied segment names are null
- */
- Path create( Path parentPath,
- Name... segmentNames );
+ /**
+ * Create a path by appending the supplied names to the parent path. If no names are appended, the parent path is returned.
+ *
+ * @param parentPath the path that is to provide the basis for the new path
+ * @param segmentNames the names of the segments that are to be appended, in order, to the parent path
+ * @return the new path
+ * @throws IllegalArgumentException if the parent path reference is null, or if at least one segment name is provided and if
+ * any of the supplied segment names are null
+ */
+ Path create( Path parentPath, Name... segmentNames );
- /**
- * Create a path by appending the supplied names to the parent path. If no names are appended, the parent path is returned.
- *
- * @param parentPath the path that is to provide the basis for the new path
- * @param segments the segments that are to be appended, in order, to the parent path
- * @return the new path
- * @throws IllegalArgumentException if the parent path reference is null, or if at least one segment name is provided and if
- * any of the supplied segment names are null
- */
- Path create( Path parentPath,
- Path.Segment... segments );
+ /**
+ * Create a path by appending the supplied names to the parent path. If no names are appended, the parent path is returned.
+ *
+ * @param parentPath the path that is to provide the basis for the new path
+ * @param segments the segments that are to be appended, in order, to the parent path
+ * @return the new path
+ * @throws IllegalArgumentException if the parent path reference is null, or if at least one segment name is provided and if
+ * any of the supplied segment names are null
+ */
+ Path create( Path parentPath, Path.Segment... segments );
- /**
- * Create a path segment given the supplied segment name. The resulting segment will have no index.
- *
- * @param segmentName the name of the segment
- * @return the segment
- * @throws IllegalArgumentException if the segment name reference is <code>null</code> or the value could not be created
- * from the supplied string
- */
- Path.Segment createSegment( String segmentName );
+ /**
+ * Create a path segment given the supplied segment name. The resulting segment will have no index.
+ *
+ * @param segmentName the name of the segment
+ * @return the segment
+ * @throws IllegalArgumentException if the segment name reference is <code>null</code> or the value could not be created
+ * from the supplied string
+ */
+ Path.Segment createSegment( String segmentName );
- /**
- * Create a path segment given the supplied segment name. The resulting segment will have no index.
- *
- * @param segmentName the name of the segment
- * @param encoder the encoder that should be used to decode the qualified name
- * @return the segment
- * @throws IllegalArgumentException if the segment name reference is <code>null</code> or the value could not be created
- * from the supplied string
- */
- Path.Segment createSegment( String segmentName,
- TextEncoder encoder );
+ /**
+ * Create a path segment given the supplied segment name. The resulting segment will have no index.
+ *
+ * @param segmentName the name of the segment
+ * @param decoder the decoder that should be used to decode the qualified name
+ * @return the segment
+ * @throws IllegalArgumentException if the segment name reference is <code>null</code> or the value could not be created
+ * from the supplied string
+ */
+ Path.Segment createSegment( String segmentName, TextDecoder decoder );
- /**
- * Create a path segment given the supplied segment name and index.
- *
- * @param segmentName the name of the new segment
- * @param index the index of the new segment
- * @return the segment
- * @throws IllegalArgumentException if the segment name reference is <code>null</code> or if the index is invalid
- */
- Path.Segment createSegment( String segmentName,
- int index );
+ /**
+ * Create a path segment given the supplied segment name and index.
+ *
+ * @param segmentName the name of the new segment
+ * @param index the index of the new segment
+ * @return the segment
+ * @throws IllegalArgumentException if the segment name reference is <code>null</code> or if the index is invalid
+ */
+ Path.Segment createSegment( String segmentName, int index );
- /**
- * Create a path segment given the supplied segment name. The resulting segment will have no index.
- *
- * @param segmentName the name of the segment
- * @return the segment
- * @throws IllegalArgumentException if the segment name reference is null
- */
- Path.Segment createSegment( Name segmentName );
+ /**
+ * Create a path segment given the supplied segment name. The resulting segment will have no index.
+ *
+ * @param segmentName the name of the segment
+ * @return the segment
+ * @throws IllegalArgumentException if the segment name reference is null
+ */
+ Path.Segment createSegment( Name segmentName );
- /**
- * Create a path segment given the supplied segment name and index.
- *
- * @param segmentName the name of the new segment
- * @param index the index of the new segment
- * @return the segment
- * @throws IllegalArgumentException if the segment name reference is null or if the index is invalid
- */
- Path.Segment createSegment( Name segmentName,
- int index );
+ /**
+ * Create a path segment given the supplied segment name and index.
+ *
+ * @param segmentName the name of the new segment
+ * @param index the index of the new segment
+ * @return the segment
+ * @throws IllegalArgumentException if the segment name reference is null or if the index is invalid
+ */
+ Path.Segment createSegment( Name segmentName, int index );
}
Modified: trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/ValueComparators.java
===================================================================
--- trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/ValueComparators.java 2008-06-02 20:19:51 UTC (rev 234)
+++ trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/ValueComparators.java 2008-06-03 17:32:57 UTC (rev 235)
@@ -284,7 +284,7 @@
protected static final ValueFactory<String> getStringValueFactory() {
// No locking is required, because it doesn't matter if we create several instances during initialization ...
if (STRING_VALUE_FACTORY == null) {
- STRING_VALUE_FACTORY = new StringValueFactory(Path.NO_OP_ENCODER);
+ STRING_VALUE_FACTORY = new StringValueFactory(Path.NO_OP_DECODER, Path.NO_OP_ENCODER);
}
return STRING_VALUE_FACTORY;
}
Modified: trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/ValueFactory.java
===================================================================
--- trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/ValueFactory.java 2008-06-02 20:19:51 UTC (rev 234)
+++ trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/ValueFactory.java 2008-06-03 17:32:57 UTC (rev 235)
@@ -28,45 +28,52 @@
import java.net.URI;
import java.util.Calendar;
import java.util.Date;
+import org.jboss.dna.common.text.TextDecoder;
import org.jboss.dna.common.text.TextEncoder;
/**
* A factory for {@link Property} values. Some of the methods may throw a {@link ValueFormatException} if the parameter supplied
* to the <code>create(...)</code> method cannot be converted to the {@link #getPropertyType() factory's type}.
+ *
* @author Randall Hauch
* @param <T> the type of value to create
*/
public interface ValueFactory<T> {
+ static final TextDecoder DEFAULT_DECODER = Path.NO_OP_DECODER;
static final TextEncoder DEFAULT_ENCODER = Path.NO_OP_ENCODER;
/**
* Get the {@link PropertyType type} of values created by this factory.
+ *
* @return the value type; never null
*/
PropertyType getPropertyType();
/**
* Create a value from a string, using no decoding.
+ *
* @param value the string from which the value is to be created
* @return the value, or null if the supplied string is null
* @throws ValueFormatException if the value could not be created from the supplied string
- * @see #create(String, TextEncoder)
+ * @see #create(String, TextDecoder)
*/
T create( String value ) throws ValueFormatException;
/**
* Create a value from a string, using the supplied decoder.
+ *
* @param value the string from which the value is to be created
- * @param decoder the decoder that should be used; if null, the {@link #DEFAULT_ENCODER default decoder} is used
+ * @param decoder the decoder that should be used; if null, the {@link #DEFAULT_DECODER default decoder} is used
* @return the value, or null if the supplied string is null
* @throws ValueFormatException if the value could not be created from the supplied string
* @see #create(String)
*/
- T create( String value, TextEncoder decoder ) throws ValueFormatException;
+ T create( String value, TextDecoder decoder ) throws ValueFormatException;
/**
* Create a value from an integer.
+ *
* @param value the integer from which the value is to be created
* @return the value; never null
* @throws ValueFormatException if the value could not be created from the supplied integer
@@ -75,6 +82,7 @@
/**
* Create a long from a string.
+ *
* @param value the string from which the long is to be created
* @return the value; never null
* @throws ValueFormatException if the value could not be created from the supplied long
@@ -83,6 +91,7 @@
/**
* Create a boolean from a string.
+ *
* @param value the boolean from which the value is to be created
* @return the value; never null
* @throws ValueFormatException if the value could not be created from the supplied boolean
@@ -91,6 +100,7 @@
/**
* Create a value from a float.
+ *
* @param value the float from which the value is to be created
* @return the value; never null
* @throws ValueFormatException if the value could not be created from the supplied float
@@ -99,6 +109,7 @@
/**
* Create a value from a double.
+ *
* @param value the double from which the value is to be created
* @return the value; never null
* @throws ValueFormatException if the value could not be created from the supplied double
@@ -107,6 +118,7 @@
/**
* Create a value from a decimal.
+ *
* @param value the decimal from which the value is to be created
* @return the value, or null if the supplied decimal is null
* @throws ValueFormatException if the value could not be created from the supplied decimal
@@ -115,6 +127,7 @@
/**
* Create a value from a Calendar instance.
+ *
* @param value the Calendar instance from which the value is to be created
* @return the value, or null if the supplied Calendar is null
* @throws ValueFormatException if the value could not be created from the supplied Calendar object
@@ -123,6 +136,7 @@
/**
* Create a value from a date.
+ *
* @param value the date from which the value is to be created
* @return the value, or null if the supplied date is null
* @throws ValueFormatException if the value could not be created from the supplied date
@@ -131,6 +145,7 @@
/**
* Create a value from a name.
+ *
* @param value the name from which the value is to be created
* @return the value, or null if the supplied name is null
* @throws ValueFormatException if the value could not be created from the supplied name
@@ -139,6 +154,7 @@
/**
* Create a value from a path.
+ *
* @param value the path from which the value is to be created
* @return the value, or null if the supplied path is null
* @throws ValueFormatException if the value could not be created from the supplied path
@@ -147,6 +163,7 @@
/**
* Create a value from a reference.
+ *
* @param value the reference from which the value is to be created
* @return the value, or null if the supplied reference is null
* @throws ValueFormatException if the value could not be created from the supplied reference
@@ -155,6 +172,7 @@
/**
* Create a value from a URI.
+ *
* @param value the URI from which the value is to be created
* @return the value, or null if the supplied URI is null
* @throws ValueFormatException if the value could not be created from the supplied URI
@@ -163,6 +181,7 @@
/**
* Create a value from the binary content given by the supplied array.
+ *
* @param value the content to be used to create the value
* @return the value, or null if the supplied stream is null
* @throws ValueFormatException if the value could not be created from the supplied byte array
@@ -171,6 +190,7 @@
/**
* Create a value from the binary content given by the supplied stream.
+ *
* @param stream the stream containing the content to be used to create the value
* @param approximateLength the approximate length of the content (in bytes)
* @return the value, or null if the supplied stream is null
@@ -181,6 +201,7 @@
/**
* Create a value from a the binary content given by the supplied reader.
+ *
* @param reader the reader containing the content to be used to create the value
* @param approximateLength the approximate length of the content (in bytes)
* @return the value, or null if the supplied string is null
@@ -192,7 +213,8 @@
/**
* Create a value from the specified information by determining which other <code>create</code> method applies and
* delegating to that method. Note that this method only will call <code>create</code> methods that take a single parameter;
- * so this excludes {@link #create(InputStream, int)}, {@link #create(Reader, int)} and {@link #create(String, TextEncoder)}.
+ * so this excludes {@link #create(InputStream, int)}, {@link #create(Reader, int)} and {@link #create(String, TextDecoder)}.
+ *
* @param value the value
* @return the new value, or null if the supplied parameter is null
* @throws ValueFormatException if the value could not be created from the supplied stream
Modified: trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/AbstractValueFactory.java
===================================================================
--- trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/AbstractValueFactory.java 2008-06-02 20:19:51 UTC (rev 234)
+++ trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/AbstractValueFactory.java 2008-06-03 17:32:57 UTC (rev 235)
@@ -29,7 +29,7 @@
import java.util.Calendar;
import java.util.Date;
import net.jcip.annotations.Immutable;
-import org.jboss.dna.common.text.TextEncoder;
+import org.jboss.dna.common.text.TextDecoder;
import org.jboss.dna.common.util.ArgCheck;
import org.jboss.dna.spi.graph.Name;
import org.jboss.dna.spi.graph.Path;
@@ -40,20 +40,21 @@
/**
* Abstract {@link ValueFactory}.
+ *
* @author Randall Hauch
* @param <T> the property type
*/
@Immutable
public abstract class AbstractValueFactory<T> implements ValueFactory<T> {
- private final TextEncoder encoder;
+ private final TextDecoder decoder;
private final PropertyType propertyType;
private final ValueFactory<String> stringValueFactory;
- protected AbstractValueFactory( PropertyType type, TextEncoder encoder, ValueFactory<String> stringValueFactory ) {
+ protected AbstractValueFactory( PropertyType type, TextDecoder decoder, ValueFactory<String> stringValueFactory ) {
ArgCheck.isNotNull(type, "type");
this.propertyType = type;
- this.encoder = encoder != null ? encoder : DEFAULT_ENCODER;
+ this.decoder = decoder != null ? decoder : DEFAULT_DECODER;
this.stringValueFactory = stringValueFactory;
}
@@ -65,20 +66,22 @@
}
/**
- * Get the text encoder/decoder.
- * @return encoder/decoder
+ * Get the text decoder.
+ *
+ * @return the decoder
*/
- public TextEncoder getEncoder() {
- return this.encoder;
+ public TextDecoder getDecoder() {
+ return this.decoder;
}
/**
- * Utility method to obtain either the supplied encoder (if not null) or this factory's {@link #getEncoder() encoder}.
- * @param encoder the encoder, which may be null if this factory's {@link #getEncoder() is to be used}
- * @return the encoder; never null
+ * Utility method to obtain either the supplied decoder (if not null) or this factory's {@link #getDecoder() decoder}.
+ *
+ * @param decoder the decoder, which may be null if this factory's {@link #getDecoder() is to be used}
+ * @return the decoder; never null
*/
- protected TextEncoder getEncoder( TextEncoder encoder ) {
- return encoder != null ? encoder : this.getEncoder();
+ protected TextDecoder getDecoder( TextDecoder decoder ) {
+ return decoder != null ? decoder : this.getDecoder();
}
/**
Modified: trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/BooleanValueFactory.java
===================================================================
--- trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/BooleanValueFactory.java 2008-06-02 20:19:51 UTC (rev 234)
+++ trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/BooleanValueFactory.java 2008-06-03 17:32:57 UTC (rev 235)
@@ -29,7 +29,7 @@
import java.util.Calendar;
import java.util.Date;
import net.jcip.annotations.Immutable;
-import org.jboss.dna.common.text.TextEncoder;
+import org.jboss.dna.common.text.TextDecoder;
import org.jboss.dna.spi.SpiI18n;
import org.jboss.dna.spi.graph.Name;
import org.jboss.dna.spi.graph.Path;
@@ -40,13 +40,14 @@
/**
* The standard {@link ValueFactory} for {@link PropertyType#BOOLEAN} values.
+ *
* @author Randall Hauch
*/
@Immutable
public class BooleanValueFactory extends AbstractValueFactory<Boolean> {
- public BooleanValueFactory( TextEncoder encoder, ValueFactory<String> stringValueFactory ) {
- super(PropertyType.BOOLEAN, encoder, stringValueFactory);
+ public BooleanValueFactory( TextDecoder decoder, ValueFactory<String> stringValueFactory ) {
+ super(PropertyType.BOOLEAN, decoder, stringValueFactory);
}
/**
@@ -60,9 +61,9 @@
/**
* {@inheritDoc}
*/
- public Boolean create( String value, TextEncoder decoder ) {
+ public Boolean create( String value, TextDecoder decoder ) {
// this probably doesn't really need to call the decoder, but by doing so then we don't care at all what the decoder does
- return create(getEncoder(decoder).decode(value));
+ return create(getDecoder(decoder).decode(value));
}
/**
Modified: trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/DecimalValueFactory.java
===================================================================
--- trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/DecimalValueFactory.java 2008-06-02 20:19:51 UTC (rev 234)
+++ trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/DecimalValueFactory.java 2008-06-03 17:32:57 UTC (rev 235)
@@ -29,7 +29,7 @@
import java.util.Calendar;
import java.util.Date;
import net.jcip.annotations.Immutable;
-import org.jboss.dna.common.text.TextEncoder;
+import org.jboss.dna.common.text.TextDecoder;
import org.jboss.dna.spi.SpiI18n;
import org.jboss.dna.spi.graph.Name;
import org.jboss.dna.spi.graph.Path;
@@ -40,13 +40,14 @@
/**
* The standard {@link ValueFactory} for {@link PropertyType#DECIMAL} values.
+ *
* @author Randall Hauch
*/
@Immutable
public class DecimalValueFactory extends AbstractValueFactory<BigDecimal> {
- public DecimalValueFactory( TextEncoder encoder, ValueFactory<String> stringValueFactory ) {
- super(PropertyType.DECIMAL, encoder, stringValueFactory);
+ public DecimalValueFactory( TextDecoder decoder, ValueFactory<String> stringValueFactory ) {
+ super(PropertyType.DECIMAL, decoder, stringValueFactory);
}
/**
@@ -64,9 +65,9 @@
/**
* {@inheritDoc}
*/
- public BigDecimal create( String value, TextEncoder decoder ) {
+ public BigDecimal create( String value, TextDecoder decoder ) {
// this probably doesn't really need to call the decoder, but by doing so then we don't care at all what the decoder does
- return create(getEncoder(decoder).decode(value.trim()));
+ return create(getDecoder(decoder).decode(value.trim()));
}
/**
Modified: trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/DoubleValueFactory.java
===================================================================
--- trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/DoubleValueFactory.java 2008-06-02 20:19:51 UTC (rev 234)
+++ trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/DoubleValueFactory.java 2008-06-03 17:32:57 UTC (rev 235)
@@ -29,7 +29,7 @@
import java.util.Calendar;
import java.util.Date;
import net.jcip.annotations.Immutable;
-import org.jboss.dna.common.text.TextEncoder;
+import org.jboss.dna.common.text.TextDecoder;
import org.jboss.dna.spi.SpiI18n;
import org.jboss.dna.spi.graph.Name;
import org.jboss.dna.spi.graph.Path;
@@ -40,13 +40,14 @@
/**
* The standard {@link ValueFactory} for {@link PropertyType#DOUBLE} values.
+ *
* @author Randall Hauch
*/
@Immutable
public class DoubleValueFactory extends AbstractValueFactory<Double> {
- public DoubleValueFactory( TextEncoder encoder, ValueFactory<String> stringValueFactory ) {
- super(PropertyType.DOUBLE, encoder, stringValueFactory);
+ public DoubleValueFactory( TextDecoder decoder, ValueFactory<String> stringValueFactory ) {
+ super(PropertyType.DOUBLE, decoder, stringValueFactory);
}
/**
@@ -64,9 +65,9 @@
/**
* {@inheritDoc}
*/
- public Double create( String value, TextEncoder decoder ) {
+ public Double create( String value, TextDecoder decoder ) {
// this probably doesn't really need to call the decoder, but by doing so then we don't care at all what the decoder does
- return create(getEncoder(decoder).decode(value));
+ return create(getDecoder(decoder).decode(value));
}
/**
Modified: trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/InMemoryBinaryValueFactory.java
===================================================================
--- trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/InMemoryBinaryValueFactory.java 2008-06-02 20:19:51 UTC (rev 234)
+++ trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/InMemoryBinaryValueFactory.java 2008-06-03 17:32:57 UTC (rev 235)
@@ -30,7 +30,7 @@
import java.util.Calendar;
import java.util.Date;
import net.jcip.annotations.Immutable;
-import org.jboss.dna.common.text.TextEncoder;
+import org.jboss.dna.common.text.TextDecoder;
import org.jboss.dna.common.util.IoUtil;
import org.jboss.dna.spi.SpiI18n;
import org.jboss.dna.spi.graph.Binary;
@@ -43,6 +43,7 @@
/**
* Teh standard {@link ValueFactory} for {@link PropertyType#BINARY} values.
+ *
* @author Randall Hauch
*/
@Immutable
@@ -50,8 +51,8 @@
private static final String CHAR_SET_NAME = "UTF-8";
- public InMemoryBinaryValueFactory( TextEncoder encoder, ValueFactory<String> stringValueFactory ) {
- super(PropertyType.BINARY, encoder, stringValueFactory);
+ public InMemoryBinaryValueFactory( TextDecoder decoder, ValueFactory<String> stringValueFactory ) {
+ super(PropertyType.BINARY, decoder, stringValueFactory);
}
/**
@@ -69,9 +70,9 @@
/**
* {@inheritDoc}
*/
- public Binary create( String value, TextEncoder decoder ) throws ValueFormatException {
+ public Binary create( String value, TextDecoder decoder ) throws ValueFormatException {
if (value == null) return null;
- return create(getEncoder(decoder).decode(value));
+ return create(getDecoder(decoder).decode(value));
}
/**
Modified: trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/JodaDateTimeValueFactory.java
===================================================================
--- trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/JodaDateTimeValueFactory.java 2008-06-02 20:19:51 UTC (rev 234)
+++ trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/JodaDateTimeValueFactory.java 2008-06-03 17:32:57 UTC (rev 235)
@@ -29,7 +29,7 @@
import java.util.Calendar;
import java.util.Date;
import net.jcip.annotations.Immutable;
-import org.jboss.dna.common.text.TextEncoder;
+import org.jboss.dna.common.text.TextDecoder;
import org.jboss.dna.spi.SpiI18n;
import org.jboss.dna.spi.graph.DateTime;
import org.jboss.dna.spi.graph.DateTimeFactory;
@@ -42,13 +42,14 @@
/**
* The standard {@link ValueFactory} for {@link PropertyType#DATE} values.
+ *
* @author Randall Hauch
*/
@Immutable
public class JodaDateTimeValueFactory extends AbstractValueFactory<DateTime> implements DateTimeFactory {
- public JodaDateTimeValueFactory( TextEncoder encoder, ValueFactory<String> stringValueFactory ) {
- super(PropertyType.DATE, encoder, stringValueFactory);
+ public JodaDateTimeValueFactory( TextDecoder decoder, ValueFactory<String> stringValueFactory ) {
+ super(PropertyType.DATE, decoder, stringValueFactory);
}
/**
@@ -66,9 +67,9 @@
/**
* {@inheritDoc}
*/
- public DateTime create( String value, TextEncoder decoder ) {
+ public DateTime create( String value, TextDecoder decoder ) {
// this probably doesn't really need to call the decoder, but by doing so then we don't care at all what the decoder does
- return create(getEncoder(decoder).decode(value));
+ return create(getDecoder(decoder).decode(value));
}
/**
Modified: trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/LongValueFactory.java
===================================================================
--- trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/LongValueFactory.java 2008-06-02 20:19:51 UTC (rev 234)
+++ trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/LongValueFactory.java 2008-06-03 17:32:57 UTC (rev 235)
@@ -29,7 +29,7 @@
import java.util.Calendar;
import java.util.Date;
import net.jcip.annotations.Immutable;
-import org.jboss.dna.common.text.TextEncoder;
+import org.jboss.dna.common.text.TextDecoder;
import org.jboss.dna.spi.SpiI18n;
import org.jboss.dna.spi.graph.Name;
import org.jboss.dna.spi.graph.Path;
@@ -40,13 +40,14 @@
/**
* The standard {@link ValueFactory} for {@link PropertyType#LONG} values.
+ *
* @author Randall Hauch
*/
@Immutable
public class LongValueFactory extends AbstractValueFactory<Long> {
- public LongValueFactory( TextEncoder encoder, ValueFactory<String> stringValueFactory ) {
- super(PropertyType.LONG, encoder, stringValueFactory);
+ public LongValueFactory( TextDecoder decoder, ValueFactory<String> stringValueFactory ) {
+ super(PropertyType.LONG, decoder, stringValueFactory);
}
/**
@@ -64,9 +65,9 @@
/**
* {@inheritDoc}
*/
- public Long create( String value, TextEncoder decoder ) {
+ public Long create( String value, TextDecoder decoder ) {
// this probably doesn't really need to call the decoder, but by doing so then we don't care at all what the decoder does
- return create(getEncoder(decoder).decode(value));
+ return create(getDecoder(decoder).decode(value));
}
/**
Modified: trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/NameValueFactory.java
===================================================================
--- trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/NameValueFactory.java 2008-06-02 20:19:51 UTC (rev 234)
+++ trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/NameValueFactory.java 2008-06-03 17:32:57 UTC (rev 235)
@@ -31,7 +31,7 @@
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import net.jcip.annotations.Immutable;
-import org.jboss.dna.common.text.TextEncoder;
+import org.jboss.dna.common.text.TextDecoder;
import org.jboss.dna.common.util.ArgCheck;
import org.jboss.dna.spi.SpiI18n;
import org.jboss.dna.spi.graph.Name;
@@ -46,256 +46,222 @@
/**
* The standard {@link ValueFactory} for {@link PropertyType#NAME} values.
- *
+ *
* @author Randall Hauch
*/
@Immutable
public class NameValueFactory extends AbstractValueFactory<Name> implements NameFactory {
- // Non-escaped pattern: (\{([^}]*)\})?(.*)
- protected static final String FULLY_QUALFIED_NAME_PATTERN_STRING = "\\{([^}]*)\\}(.*)";
- protected static final Pattern FULLY_QUALIFIED_NAME_PATTERN = Pattern.compile(FULLY_QUALFIED_NAME_PATTERN_STRING);
+ // Non-escaped pattern: (\{([^}]*)\})?(.*)
+ protected static final String FULLY_QUALFIED_NAME_PATTERN_STRING = "\\{([^}]*)\\}(.*)";
+ protected static final Pattern FULLY_QUALIFIED_NAME_PATTERN = Pattern.compile(FULLY_QUALFIED_NAME_PATTERN_STRING);
- // Original pattern: (([^:/]*):)?(.*)
- private static final String PREFIXED_NAME_PATTERN_STRING = "(([^:/]*):)?(.*)";
- private static final Pattern PREFIXED_NAME_PATTERN = Pattern.compile(PREFIXED_NAME_PATTERN_STRING);
+ // Original pattern: (([^:/]*):)?(.*)
+ private static final String PREFIXED_NAME_PATTERN_STRING = "(([^:/]*):)?(.*)";
+ private static final Pattern PREFIXED_NAME_PATTERN = Pattern.compile(PREFIXED_NAME_PATTERN_STRING);
- private final NamespaceRegistry namespaceRegistry;
+ private final NamespaceRegistry namespaceRegistry;
- public NameValueFactory( NamespaceRegistry namespaceRegistry,
- TextEncoder encoder,
- ValueFactory<String> stringValueFactory ) {
- super(PropertyType.NAME, encoder, stringValueFactory);
- ArgCheck.isNotNull(namespaceRegistry, "namespaceRegistry");
- this.namespaceRegistry = namespaceRegistry;
- }
+ public NameValueFactory( NamespaceRegistry namespaceRegistry, TextDecoder decoder, ValueFactory<String> stringValueFactory ) {
+ super(PropertyType.NAME, decoder, stringValueFactory);
+ ArgCheck.isNotNull(namespaceRegistry, "namespaceRegistry");
+ this.namespaceRegistry = namespaceRegistry;
+ }
- /**
- * {@inheritDoc}
- */
- public Name create( String value ) {
- return create(value, getEncoder());
- }
+ /**
+ * {@inheritDoc}
+ */
+ public Name create( String value ) {
+ return create(value, getDecoder());
+ }
- /**
- * {@inheritDoc}
- */
- public Name create( String value,
- TextEncoder decoder ) throws ValueFormatException {
- if (value == null) return null;
- if (decoder == null) decoder = getEncoder();
- try {
- // First see whether the value fits the internal pattern ...
- Matcher matcher = FULLY_QUALIFIED_NAME_PATTERN.matcher(value);
- if (matcher.matches()) {
- String namespaceUri = matcher.group(1);
- String localName = matcher.group(2);
- // Decode the parts ...
- namespaceUri = decoder.decode(namespaceUri);
- localName = decoder.decode(localName);
- return new BasicName(namespaceUri, localName);
- }
- // Second, see whether the value fits the prefixed name pattern ...
- matcher = PREFIXED_NAME_PATTERN.matcher(value);
- if (matcher.matches()) {
- String prefix = matcher.group(2);
- String localName = matcher.group(3);
- // Decode the parts ...
- prefix = prefix == null ? "" : decoder.decode(prefix);
- localName = decoder.decode(localName);
- // Look for a namespace match ...
- String namespaceUri = this.namespaceRegistry.getNamespaceForPrefix(prefix);
- // Fail if no namespace is found ...
- if (namespaceUri == null) {
- throw new NamespaceException(SpiI18n.noNamespaceRegisteredForPrefix.text(prefix));
- }
- return new BasicName(namespaceUri, localName);
- }
- } catch (Throwable t) {
- throw new ValueFormatException(SpiI18n.errorCreatingValue.text(getPropertyType().getName(),
- String.class.getSimpleName(),
- value), t);
- }
- throw new ValueFormatException(SpiI18n.errorCreatingValue.text(getPropertyType().getName(),
- String.class.getSimpleName(),
- value));
- }
+ /**
+ * {@inheritDoc}
+ */
+ public Name create( String value, TextDecoder decoder ) throws ValueFormatException {
+ if (value == null) return null;
+ if (decoder == null) decoder = getDecoder();
+ try {
+ // First see whether the value fits the internal pattern ...
+ Matcher matcher = FULLY_QUALIFIED_NAME_PATTERN.matcher(value);
+ if (matcher.matches()) {
+ String namespaceUri = matcher.group(1);
+ String localName = matcher.group(2);
+ // Decode the parts ...
+ namespaceUri = decoder.decode(namespaceUri);
+ localName = decoder.decode(localName);
+ return new BasicName(namespaceUri, localName);
+ }
+ // Second, see whether the value fits the prefixed name pattern ...
+ matcher = PREFIXED_NAME_PATTERN.matcher(value);
+ if (matcher.matches()) {
+ String prefix = matcher.group(2);
+ String localName = matcher.group(3);
+ // Decode the parts ...
+ prefix = prefix == null ? "" : decoder.decode(prefix);
+ localName = decoder.decode(localName);
+ // Look for a namespace match ...
+ String namespaceUri = this.namespaceRegistry.getNamespaceForPrefix(prefix);
+ // Fail if no namespace is found ...
+ if (namespaceUri == null) {
+ throw new NamespaceException(SpiI18n.noNamespaceRegisteredForPrefix.text(prefix));
+ }
+ return new BasicName(namespaceUri, localName);
+ }
+ } catch (Throwable t) {
+ throw new ValueFormatException(SpiI18n.errorCreatingValue.text(getPropertyType().getName(), String.class.getSimpleName(), value), t);
+ }
+ throw new ValueFormatException(SpiI18n.errorCreatingValue.text(getPropertyType().getName(), String.class.getSimpleName(), value));
+ }
- /**
- * {@inheritDoc}
- */
- public Name create( String namespaceUri,
- String localName ) {
- return create(namespaceUri, localName, getEncoder());
- }
+ /**
+ * {@inheritDoc}
+ */
+ public Name create( String namespaceUri, String localName ) {
+ return create(namespaceUri, localName, getDecoder());
+ }
- /**
- * {@inheritDoc}
- */
- public Name create( String namespaceUri,
- String localName,
- TextEncoder decoder ) {
- ArgCheck.isNotEmpty(localName, "localName");
- if (decoder == null) decoder = getEncoder();
- namespaceUri = namespaceUri != null ? decoder.decode(namespaceUri.trim()) : null;
- localName = decoder.decode(localName.trim());
- return new BasicName(namespaceUri, localName);
- }
+ /**
+ * {@inheritDoc}
+ */
+ public Name create( String namespaceUri, String localName, TextDecoder decoder ) {
+ ArgCheck.isNotEmpty(localName, "localName");
+ if (decoder == null) decoder = getDecoder();
+ namespaceUri = namespaceUri != null ? decoder.decode(namespaceUri.trim()) : null;
+ localName = decoder.decode(localName.trim());
+ return new BasicName(namespaceUri, localName);
+ }
- /**
- * {@inheritDoc}
- */
- public Name create( int value ) throws ValueFormatException {
- throw new ValueFormatException(SpiI18n.unableToCreateValue.text(getPropertyType().getName(),
- Date.class.getSimpleName(),
- value));
- }
+ /**
+ * {@inheritDoc}
+ */
+ public Name create( int value ) throws ValueFormatException {
+ throw new ValueFormatException(SpiI18n.unableToCreateValue.text(getPropertyType().getName(), Date.class.getSimpleName(), value));
+ }
- /**
- * {@inheritDoc}
- */
- public Name create( long value ) throws ValueFormatException {
- throw new ValueFormatException(SpiI18n.unableToCreateValue.text(getPropertyType().getName(),
- Date.class.getSimpleName(),
- value));
- }
+ /**
+ * {@inheritDoc}
+ */
+ public Name create( long value ) throws ValueFormatException {
+ throw new ValueFormatException(SpiI18n.unableToCreateValue.text(getPropertyType().getName(), Date.class.getSimpleName(), value));
+ }
- /**
- * {@inheritDoc}
- */
- public Name create( boolean value ) throws ValueFormatException {
- throw new ValueFormatException(SpiI18n.unableToCreateValue.text(getPropertyType().getName(),
- Date.class.getSimpleName(),
- value));
- }
+ /**
+ * {@inheritDoc}
+ */
+ public Name create( boolean value ) throws ValueFormatException {
+ throw new ValueFormatException(SpiI18n.unableToCreateValue.text(getPropertyType().getName(), Date.class.getSimpleName(), value));
+ }
- /**
- * {@inheritDoc}
- */
- public Name create( float value ) throws ValueFormatException {
- throw new ValueFormatException(SpiI18n.unableToCreateValue.text(getPropertyType().getName(),
- Date.class.getSimpleName(),
- value));
- }
+ /**
+ * {@inheritDoc}
+ */
+ public Name create( float value ) throws ValueFormatException {
+ throw new ValueFormatException(SpiI18n.unableToCreateValue.text(getPropertyType().getName(), Date.class.getSimpleName(), value));
+ }
- /**
- * {@inheritDoc}
- */
- public Name create( double value ) throws ValueFormatException {
- throw new ValueFormatException(SpiI18n.unableToCreateValue.text(getPropertyType().getName(),
- Date.class.getSimpleName(),
- value));
- }
+ /**
+ * {@inheritDoc}
+ */
+ public Name create( double value ) throws ValueFormatException {
+ throw new ValueFormatException(SpiI18n.unableToCreateValue.text(getPropertyType().getName(), Date.class.getSimpleName(), value));
+ }
- /**
- * {@inheritDoc}
- */
- public Name create( BigDecimal value ) throws ValueFormatException {
- throw new ValueFormatException(SpiI18n.unableToCreateValue.text(getPropertyType().getName(),
- Date.class.getSimpleName(),
- value));
- }
+ /**
+ * {@inheritDoc}
+ */
+ public Name create( BigDecimal value ) throws ValueFormatException {
+ throw new ValueFormatException(SpiI18n.unableToCreateValue.text(getPropertyType().getName(), Date.class.getSimpleName(), value));
+ }
- /**
- * {@inheritDoc}
- */
- public Name create( Calendar value ) throws ValueFormatException {
- throw new ValueFormatException(SpiI18n.unableToCreateValue.text(getPropertyType().getName(),
- Date.class.getSimpleName(),
- value));
- }
+ /**
+ * {@inheritDoc}
+ */
+ public Name create( Calendar value ) throws ValueFormatException {
+ throw new ValueFormatException(SpiI18n.unableToCreateValue.text(getPropertyType().getName(), Date.class.getSimpleName(), value));
+ }
- /**
- * {@inheritDoc}
- */
- public Name create( Date value ) throws ValueFormatException {
- throw new ValueFormatException(SpiI18n.unableToCreateValue.text(getPropertyType().getName(),
- Date.class.getSimpleName(),
- value));
- }
+ /**
+ * {@inheritDoc}
+ */
+ public Name create( Date value ) throws ValueFormatException {
+ throw new ValueFormatException(SpiI18n.unableToCreateValue.text(getPropertyType().getName(), Date.class.getSimpleName(), value));
+ }
- /**
- * {@inheritDoc}
- */
- public Name create( Name value ) {
- return value;
- }
+ /**
+ * {@inheritDoc}
+ */
+ public Name create( Name value ) {
+ return value;
+ }
- /**
- * {@inheritDoc}
- */
- public Name create( Path value ) throws ValueFormatException {
- if (value == null) return null;
- if (!value.isAbsolute() && value.size() == 1) {
- // A relative name of length 1 is converted to a name
- return value.getSegment(0).getName();
- }
- throw new ValueFormatException(SpiI18n.errorCreatingValue.text(getPropertyType().getName(),
- Path.class.getSimpleName(),
- value));
- }
+ /**
+ * {@inheritDoc}
+ */
+ public Name create( Path value ) throws ValueFormatException {
+ if (value == null) return null;
+ if (!value.isAbsolute() && value.size() == 1) {
+ // A relative name of length 1 is converted to a name
+ return value.getSegment(0).getName();
+ }
+ throw new ValueFormatException(SpiI18n.errorCreatingValue.text(getPropertyType().getName(), Path.class.getSimpleName(), value));
+ }
- /**
- * {@inheritDoc}
- */
- public Name create( Reference value ) throws ValueFormatException {
- throw new ValueFormatException(SpiI18n.unableToCreateValue.text(getPropertyType().getName(),
- Reference.class.getSimpleName(),
- value));
- }
+ /**
+ * {@inheritDoc}
+ */
+ public Name create( Reference value ) throws ValueFormatException {
+ throw new ValueFormatException(SpiI18n.unableToCreateValue.text(getPropertyType().getName(), Reference.class.getSimpleName(), value));
+ }
- /**
- * {@inheritDoc}
- */
- public Name create( URI value ) throws ValueFormatException {
- if (value == null) return null;
- String asciiString = value.toASCIIString();
- // Remove any leading "./" ...
- if (asciiString.startsWith("./") && asciiString.length() > 2) {
- asciiString = asciiString.substring(2);
- }
- if (asciiString.indexOf('/') == -1) {
- return create(asciiString);
- }
- throw new ValueFormatException(SpiI18n.errorCreatingValue.text(getPropertyType().getName(),
- Path.class.getSimpleName(),
- value));
- }
+ /**
+ * {@inheritDoc}
+ */
+ public Name create( URI value ) throws ValueFormatException {
+ if (value == null) return null;
+ String asciiString = value.toASCIIString();
+ // Remove any leading "./" ...
+ if (asciiString.startsWith("./") && asciiString.length() > 2) {
+ asciiString = asciiString.substring(2);
+ }
+ if (asciiString.indexOf('/') == -1) {
+ return create(asciiString);
+ }
+ throw new ValueFormatException(SpiI18n.errorCreatingValue.text(getPropertyType().getName(), Path.class.getSimpleName(), value));
+ }
- /**
- * {@inheritDoc}
- */
- public Name create( byte[] value ) throws ValueFormatException {
- // First attempt to create a string from the value, then a long from the string ...
- return create(getStringValueFactory().create(value));
- }
+ /**
+ * {@inheritDoc}
+ */
+ public Name create( byte[] value ) throws ValueFormatException {
+ // First attempt to create a string from the value, then a long from the string ...
+ return create(getStringValueFactory().create(value));
+ }
- /**
- * {@inheritDoc}
- */
- public Name create( InputStream stream,
- int approximateLength ) throws IOException, ValueFormatException {
- // First attempt to create a string from the value, then a double from the string ...
- return create(getStringValueFactory().create(stream, approximateLength));
- }
+ /**
+ * {@inheritDoc}
+ */
+ public Name create( InputStream stream, int approximateLength ) throws IOException, ValueFormatException {
+ // First attempt to create a string from the value, then a double from the string ...
+ return create(getStringValueFactory().create(stream, approximateLength));
+ }
- /**
- * {@inheritDoc}
- */
- public Name create( Reader reader,
- int approximateLength ) throws IOException, ValueFormatException {
- // First attempt to create a string from the value, then a double from the string ...
- return create(getStringValueFactory().create(reader, approximateLength));
- }
+ /**
+ * {@inheritDoc}
+ */
+ public Name create( Reader reader, int approximateLength ) throws IOException, ValueFormatException {
+ // First attempt to create a string from the value, then a double from the string ...
+ return create(getStringValueFactory().create(reader, approximateLength));
+ }
- /**
- * <p>
- * {@inheritDoc}
- * </p>
- *
- * @see org.jboss.dna.spi.graph.NameFactory#getNamespaceRegistry()
- */
- public NamespaceRegistry getNamespaceRegistry() {
- return namespaceRegistry;
- }
+ /**
+ * <p>
+ * {@inheritDoc}
+ * </p>
+ *
+ * @see org.jboss.dna.spi.graph.NameFactory#getNamespaceRegistry()
+ */
+ public NamespaceRegistry getNamespaceRegistry() {
+ return namespaceRegistry;
+ }
}
Modified: trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/ObjectValueFactory.java
===================================================================
--- trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/ObjectValueFactory.java 2008-06-02 20:19:51 UTC (rev 234)
+++ trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/ObjectValueFactory.java 2008-06-03 17:32:57 UTC (rev 235)
@@ -29,7 +29,7 @@
import java.util.Calendar;
import java.util.Date;
import net.jcip.annotations.Immutable;
-import org.jboss.dna.common.text.TextEncoder;
+import org.jboss.dna.common.text.TextDecoder;
import org.jboss.dna.common.util.ArgCheck;
import org.jboss.dna.spi.graph.Binary;
import org.jboss.dna.spi.graph.Name;
@@ -41,6 +41,7 @@
/**
* The standard {@link ValueFactory} for {@link PropertyType#OBJECT} values.
+ *
* @author Randall Hauch
*/
@Immutable
@@ -48,8 +49,8 @@
private final ValueFactory<Binary> binaryValueFactory;
- public ObjectValueFactory( TextEncoder encoder, ValueFactory<String> stringValueFactory, ValueFactory<Binary> binaryValueFactory ) {
- super(PropertyType.OBJECT, encoder, stringValueFactory);
+ public ObjectValueFactory( TextDecoder decoder, ValueFactory<String> stringValueFactory, ValueFactory<Binary> binaryValueFactory ) {
+ super(PropertyType.OBJECT, decoder, stringValueFactory);
ArgCheck.isNotNull(binaryValueFactory, "binaryValueFactory");
this.binaryValueFactory = binaryValueFactory;
}
@@ -71,7 +72,7 @@
/**
* {@inheritDoc}
*/
- public Object create( String value, TextEncoder decoder ) {
+ public Object create( String value, TextDecoder decoder ) {
return this.getStringValueFactory().create(value, decoder);
}
Modified: trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/PathValueFactory.java
===================================================================
--- trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/PathValueFactory.java 2008-06-02 20:19:51 UTC (rev 234)
+++ trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/PathValueFactory.java 2008-06-03 17:32:57 UTC (rev 235)
@@ -32,7 +32,7 @@
import java.util.List;
import java.util.regex.Pattern;
import net.jcip.annotations.Immutable;
-import org.jboss.dna.common.text.TextEncoder;
+import org.jboss.dna.common.text.TextDecoder;
import org.jboss.dna.common.util.ArgCheck;
import org.jboss.dna.spi.SpiI18n;
import org.jboss.dna.spi.graph.Name;
@@ -53,446 +53,414 @@
@Immutable
public class PathValueFactory extends AbstractValueFactory<Path> implements PathFactory {
- /**
- * Regular expression used to identify the different segments in a path, using the standard '/' delimiter. The expression is
- * simply:
- *
- * <pre>
- * /
- * </pre>
- */
- protected static final Pattern DELIMITER_PATTERN = Pattern.compile("/");
+ /**
+ * Regular expression used to identify the different segments in a path, using the standard '/' delimiter. The expression is
+ * simply:
+ *
+ * <pre>
+ * /
+ * </pre>
+ */
+ protected static final Pattern DELIMITER_PATTERN = Pattern.compile("/");
- /**
- * Regular expression used to identify the different parts of a segment. The expression is
- *
- * <pre>
- * ([ˆ*:/\[\]|]+)(:([ˆ*:/\[\]|]+))?(\[(\d+)])?
- * </pre>
- *
- * where the first part is accessed with group 1, the second part is accessed with group 3, and the index is accessed with
- * group 5.
- */
- protected static final Pattern SEGMENT_PATTERN = Pattern.compile("([^:/]+)(:([^/\\[\\]]+))?(\\[(\\d+)])?");
+ /**
+ * Regular expression used to identify the different parts of a segment. The expression is
+ *
+ * <pre>
+ * ([ˆ*:/\[\]|]+)(:([ˆ*:/\[\]|]+))?(\[(\d+)])?
+ * </pre>
+ *
+ * where the first part is accessed with group 1, the second part is accessed with group 3, and the index is accessed with
+ * group 5.
+ */
+ protected static final Pattern SEGMENT_PATTERN = Pattern.compile("([^:/]+)(:([^/\\[\\]]+))?(\\[(\\d+)])?");
- private final ValueFactory<Name> nameValueFactory;
+ private final ValueFactory<Name> nameValueFactory;
- public PathValueFactory( TextEncoder encoder,
- ValueFactory<String> stringValueFactory,
- ValueFactory<Name> nameValueFactory ) {
- super(PropertyType.PATH, encoder, stringValueFactory);
- ArgCheck.isNotNull(nameValueFactory, "nameValueFactory");
- this.nameValueFactory = nameValueFactory;
- }
+ public PathValueFactory( TextDecoder decoder, ValueFactory<String> stringValueFactory, ValueFactory<Name> nameValueFactory ) {
+ super(PropertyType.PATH, decoder, stringValueFactory);
+ ArgCheck.isNotNull(nameValueFactory, "nameValueFactory");
+ this.nameValueFactory = nameValueFactory;
+ }
- /**
- * @return nameValueFactory
- */
- protected ValueFactory<Name> getNameValueFactory() {
- return this.nameValueFactory;
- }
+ /**
+ * @return nameValueFactory
+ */
+ protected ValueFactory<Name> getNameValueFactory() {
+ return this.nameValueFactory;
+ }
- /**
- * <p>
- * {@inheritDoc}
- * </p>
- *
- * @see org.jboss.dna.spi.graph.PathFactory#create()
- */
- public Path create() {
- return BasicPath.ROOT;
- }
+ /**
+ * <p>
+ * {@inheritDoc}
+ * </p>
+ *
+ * @see org.jboss.dna.spi.graph.PathFactory#create()
+ */
+ public Path create() {
+ return BasicPath.ROOT;
+ }
- /**
- * {@inheritDoc}
- */
- public Path create( String value ) {
- return create(value, getEncoder());
- }
+ /**
+ * {@inheritDoc}
+ */
+ public Path create( String value ) {
+ return create(value, getDecoder());
+ }
- /**
- * {@inheritDoc}
- */
- public Path create( final String value,
- TextEncoder decoder ) throws ValueFormatException {
- if (value == null) return null;
- if (decoder == null) decoder = getEncoder();
- String trimmedValue = value.trim();
- int length = trimmedValue.length();
- boolean absolute = false;
- if (length == 0) {
- return BasicPath.ROOT;
- }
+ /**
+ * {@inheritDoc}
+ */
+ public Path create( final String value, TextDecoder decoder ) throws ValueFormatException {
+ if (value == null) return null;
+ String trimmedValue = value.trim();
+ int length = trimmedValue.length();
+ boolean absolute = false;
+ if (length == 0) {
+ return BasicPath.ROOT;
+ }
- // Remove the leading delimiter ...
- if (trimmedValue.charAt(0) == Path.DELIMITER) {
- trimmedValue = length > 1 ? trimmedValue.substring(1) : "";
- --length;
- absolute = true;
- }
- // remove the trailing delimiter ...
- if (length > 0 && trimmedValue.charAt(length - 1) == Path.DELIMITER) {
- trimmedValue = length > 1 ? trimmedValue.substring(0, length - 1) : "";
- length = trimmedValue.length();
- }
- if (length == 0) {
- return BasicPath.ROOT;
- }
+ // Remove the leading delimiter ...
+ if (trimmedValue.charAt(0) == Path.DELIMITER) {
+ trimmedValue = length > 1 ? trimmedValue.substring(1) : "";
+ --length;
+ absolute = true;
+ }
+ // remove the trailing delimiter ...
+ if (length > 0 && trimmedValue.charAt(length - 1) == Path.DELIMITER) {
+ trimmedValue = length > 1 ? trimmedValue.substring(0, length - 1) : "";
+ length = trimmedValue.length();
+ }
+ if (length == 0) {
+ return BasicPath.ROOT;
+ }
- // Parse the path into its segments ...
- List<Segment> segments = new ArrayList<Segment>();
- String[] pathSegments = DELIMITER_PATTERN.split(trimmedValue);
- if (pathSegments.length == 0) {
- throw new ValueFormatException(SpiI18n.validPathMayNotContainEmptySegment.text(value));
- }
- assert pathSegments.length != 0;
- for (String segment : pathSegments) {
- assert segment != null;
- segment = segment.trim();
- if (segment.length() == 0) {
- throw new ValueFormatException(SpiI18n.validPathMayNotContainEmptySegment.text(value));
- }
- // Create the name and add a segment with it ...
- segments.add(createSegment(segment, decoder));
- }
+ // Parse the path into its segments ...
+ List<Segment> segments = new ArrayList<Segment>();
+ String[] pathSegments = DELIMITER_PATTERN.split(trimmedValue);
+ if (pathSegments.length == 0) {
+ throw new ValueFormatException(SpiI18n.validPathMayNotContainEmptySegment.text(value));
+ }
+ if (decoder == null) decoder = getDecoder();
+ assert pathSegments.length != 0;
+ assert decoder != null;
+ for (String segment : pathSegments) {
+ assert segment != null;
+ segment = segment.trim();
+ if (segment.length() == 0) {
+ throw new ValueFormatException(SpiI18n.validPathMayNotContainEmptySegment.text(value));
+ }
+ // Create the name and add a segment with it ...
+ segments.add(createSegment(segment, decoder));
+ }
- // Create a path constructed from the supplied segments ...
- return new BasicPath(segments, absolute);
- }
+ // Create a path constructed from the supplied segments ...
+ return new BasicPath(segments, absolute);
+ }
- /**
- * {@inheritDoc}
- */
- public Path create( int value ) throws ValueFormatException {
- throw new ValueFormatException(SpiI18n.unableToCreateValue.text(getPropertyType().getName(),
- Date.class.getSimpleName(),
- value));
- }
+ /**
+ * {@inheritDoc}
+ */
+ public Path create( int value ) throws ValueFormatException {
+ throw new ValueFormatException(SpiI18n.unableToCreateValue.text(getPropertyType().getName(), Date.class.getSimpleName(), value));
+ }
- /**
- * {@inheritDoc}
- */
- public Path create( long value ) throws ValueFormatException {
- throw new ValueFormatException(SpiI18n.unableToCreateValue.text(getPropertyType().getName(),
- Date.class.getSimpleName(),
- value));
- }
+ /**
+ * {@inheritDoc}
+ */
+ public Path create( long value ) throws ValueFormatException {
+ throw new ValueFormatException(SpiI18n.unableToCreateValue.text(getPropertyType().getName(), Date.class.getSimpleName(), value));
+ }
- /**
- * {@inheritDoc}
- */
- public Path create( boolean value ) throws ValueFormatException {
- throw new ValueFormatException(SpiI18n.unableToCreateValue.text(getPropertyType().getName(),
- Date.class.getSimpleName(),
- value));
- }
+ /**
+ * {@inheritDoc}
+ */
+ public Path create( boolean value ) throws ValueFormatException {
+ throw new ValueFormatException(SpiI18n.unableToCreateValue.text(getPropertyType().getName(), Date.class.getSimpleName(), value));
+ }
- /**
- * {@inheritDoc}
- */
- public Path create( float value ) throws ValueFormatException {
- throw new ValueFormatException(SpiI18n.unableToCreateValue.text(getPropertyType().getName(),
- Date.class.getSimpleName(),
- value));
- }
+ /**
+ * {@inheritDoc}
+ */
+ public Path create( float value ) throws ValueFormatException {
+ throw new ValueFormatException(SpiI18n.unableToCreateValue.text(getPropertyType().getName(), Date.class.getSimpleName(), value));
+ }
- /**
- * {@inheritDoc}
- */
- public Path create( double value ) throws ValueFormatException {
- throw new ValueFormatException(SpiI18n.unableToCreateValue.text(getPropertyType().getName(),
- Date.class.getSimpleName(),
- value));
- }
+ /**
+ * {@inheritDoc}
+ */
+ public Path create( double value ) throws ValueFormatException {
+ throw new ValueFormatException(SpiI18n.unableToCreateValue.text(getPropertyType().getName(), Date.class.getSimpleName(), value));
+ }
- /**
- * {@inheritDoc}
- */
- public Path create( BigDecimal value ) throws ValueFormatException {
- throw new ValueFormatException(SpiI18n.unableToCreateValue.text(getPropertyType().getName(),
- Date.class.getSimpleName(),
- value));
- }
+ /**
+ * {@inheritDoc}
+ */
+ public Path create( BigDecimal value ) throws ValueFormatException {
+ throw new ValueFormatException(SpiI18n.unableToCreateValue.text(getPropertyType().getName(), Date.class.getSimpleName(), value));
+ }
- /**
- * {@inheritDoc}
- */
- public Path create( Calendar value ) throws ValueFormatException {
- throw new ValueFormatException(SpiI18n.unableToCreateValue.text(getPropertyType().getName(),
- Date.class.getSimpleName(),
- value));
- }
+ /**
+ * {@inheritDoc}
+ */
+ public Path create( Calendar value ) throws ValueFormatException {
+ throw new ValueFormatException(SpiI18n.unableToCreateValue.text(getPropertyType().getName(), Date.class.getSimpleName(), value));
+ }
- /**
- * {@inheritDoc}
- */
- public Path create( Date value ) throws ValueFormatException {
- throw new ValueFormatException(SpiI18n.unableToCreateValue.text(getPropertyType().getName(),
- Date.class.getSimpleName(),
- value));
- }
+ /**
+ * {@inheritDoc}
+ */
+ public Path create( Date value ) throws ValueFormatException {
+ throw new ValueFormatException(SpiI18n.unableToCreateValue.text(getPropertyType().getName(), Date.class.getSimpleName(), value));
+ }
- /**
- * {@inheritDoc}
- */
- public Path create( Name value ) {
- if (value == null) return null;
- List<Path.Segment> segments = new ArrayList<Path.Segment>(1);
- segments.add(new BasicPathSegment(value));
- return new BasicPath(segments, true);
- }
+ /**
+ * {@inheritDoc}
+ */
+ public Path create( Name value ) {
+ if (value == null) return null;
+ List<Path.Segment> segments = new ArrayList<Path.Segment>(1);
+ segments.add(new BasicPathSegment(value));
+ return new BasicPath(segments, true);
+ }
- /**
- * {@inheritDoc}
- */
- public Path create( Path value ) throws ValueFormatException {
- return value;
- }
+ /**
+ * {@inheritDoc}
+ */
+ public Path create( Path value ) throws ValueFormatException {
+ return value;
+ }
- /**
- * {@inheritDoc}
- */
- public Path create( Name... segmentNames ) {
- if (segmentNames == null || segmentNames.length == 0) return BasicPath.ROOT;
- List<Segment> segments = new ArrayList<Segment>(segmentNames.length);
- for (Name segmentName : segmentNames) {
- if (segmentName == null) {
- ArgCheck.containsNoNulls(segmentNames, "segment names");
- }
- segments.add(new BasicPathSegment(segmentName));
- }
- return new BasicPath(segments, true);
- }
+ /**
+ * {@inheritDoc}
+ */
+ public Path create( Name... segmentNames ) {
+ if (segmentNames == null || segmentNames.length == 0) return BasicPath.ROOT;
+ List<Segment> segments = new ArrayList<Segment>(segmentNames.length);
+ for (Name segmentName : segmentNames) {
+ if (segmentName == null) {
+ ArgCheck.containsNoNulls(segmentNames, "segment names");
+ }
+ segments.add(new BasicPathSegment(segmentName));
+ }
+ return new BasicPath(segments, true);
+ }
- /**
- * {@inheritDoc}
- */
- public Path create( Segment... segments ) {
- if (segments == null || segments.length == 0) return BasicPath.ROOT;
- List<Segment> segmentsList = new ArrayList<Segment>(segments.length);
- for (Segment segment : segments) {
- if (segment == null) {
- ArgCheck.containsNoNulls(segments, "segments");
- }
- segmentsList.add(segment);
- }
- return new BasicPath(segmentsList, true);
- }
+ /**
+ * {@inheritDoc}
+ */
+ public Path create( Segment... segments ) {
+ if (segments == null || segments.length == 0) return BasicPath.ROOT;
+ List<Segment> segmentsList = new ArrayList<Segment>(segments.length);
+ for (Segment segment : segments) {
+ if (segment == null) {
+ ArgCheck.containsNoNulls(segments, "segments");
+ }
+ segmentsList.add(segment);
+ }
+ return new BasicPath(segmentsList, true);
+ }
- /**
- * <p>
- * {@inheritDoc}
- * </p>
- *
- * @see org.jboss.dna.spi.graph.PathFactory#createRelativePath()
- */
- public Path createRelativePath() {
- return BasicPath.SELF_PATH;
- }
+ /**
+ * <p>
+ * {@inheritDoc}
+ * </p>
+ *
+ * @see org.jboss.dna.spi.graph.PathFactory#createRelativePath()
+ */
+ public Path createRelativePath() {
+ return BasicPath.SELF_PATH;
+ }
- /**
- * {@inheritDoc}
- */
- public Path createRelativePath( Name... segmentNames ) {
- if (segmentNames == null || segmentNames.length == 0) return BasicPath.ROOT;
- List<Segment> segments = new ArrayList<Segment>(segmentNames.length);
- for (Name segmentName : segmentNames) {
- if (segmentName == null) {
- ArgCheck.containsNoNulls(segmentNames, "segment names");
- }
- segments.add(new BasicPathSegment(segmentName));
- }
- return new BasicPath(segments, false);
- }
+ /**
+ * {@inheritDoc}
+ */
+ public Path createRelativePath( Name... segmentNames ) {
+ if (segmentNames == null || segmentNames.length == 0) return BasicPath.ROOT;
+ List<Segment> segments = new ArrayList<Segment>(segmentNames.length);
+ for (Name segmentName : segmentNames) {
+ if (segmentName == null) {
+ ArgCheck.containsNoNulls(segmentNames, "segment names");
+ }
+ segments.add(new BasicPathSegment(segmentName));
+ }
+ return new BasicPath(segments, false);
+ }
- /**
- * {@inheritDoc}
- */
- public Path createRelativePath( Segment... segments ) {
- if (segments == null || segments.length == 0) return BasicPath.ROOT;
- List<Segment> segmentsList = new ArrayList<Segment>(segments.length);
- for (Segment segment : segments) {
- if (segment == null) {
- ArgCheck.containsNoNulls(segments, "segments");
- }
- segmentsList.add(segment);
- }
- return new BasicPath(segmentsList, false);
- }
+ /**
+ * {@inheritDoc}
+ */
+ public Path createRelativePath( Segment... segments ) {
+ if (segments == null || segments.length == 0) return BasicPath.ROOT;
+ List<Segment> segmentsList = new ArrayList<Segment>(segments.length);
+ for (Segment segment : segments) {
+ if (segment == null) {
+ ArgCheck.containsNoNulls(segments, "segments");
+ }
+ segmentsList.add(segment);
+ }
+ return new BasicPath(segmentsList, false);
+ }
- /**
- * {@inheritDoc}
- */
- public Path create( Path parentPath,
- Name segmentName,
- int index ) {
- ArgCheck.isNotNull(parentPath, "parent path");
- ArgCheck.isNotNull(segmentName, "segment name");
- List<Segment> segments = new ArrayList<Segment>(parentPath.size() + 1);
- segments.addAll(parentPath.getSegmentsList());
- segments.add(new BasicPathSegment(segmentName, index));
- return new BasicPath(segments, parentPath.isAbsolute());
- }
+ /**
+ * {@inheritDoc}
+ */
+ public Path create( Path parentPath, Name segmentName, int index ) {
+ ArgCheck.isNotNull(parentPath, "parent path");
+ ArgCheck.isNotNull(segmentName, "segment name");
+ List<Segment> segments = new ArrayList<Segment>(parentPath.size() + 1);
+ segments.addAll(parentPath.getSegmentsList());
+ segments.add(new BasicPathSegment(segmentName, index));
+ return new BasicPath(segments, parentPath.isAbsolute());
+ }
- /**
- * {@inheritDoc}
- */
- public Path create( Path parentPath,
- Name... segmentNames ) {
- ArgCheck.isNotNull(parentPath, "parent path");
- if (segmentNames == null || segmentNames.length == 0) return parentPath;
+ /**
+ * {@inheritDoc}
+ */
+ public Path create( Path parentPath, Name... segmentNames ) {
+ ArgCheck.isNotNull(parentPath, "parent path");
+ if (segmentNames == null || segmentNames.length == 0) return parentPath;
- List<Segment> segments = new ArrayList<Segment>(parentPath.size() + 1);
- segments.addAll(parentPath.getSegmentsList());
- for (Name segmentName : segmentNames) {
- if (segmentName == null) {
- ArgCheck.containsNoNulls(segmentNames, "segment names");
- }
- segments.add(new BasicPathSegment(segmentName));
- }
- return new BasicPath(segments, parentPath.isAbsolute());
- }
+ List<Segment> segments = new ArrayList<Segment>(parentPath.size() + 1);
+ segments.addAll(parentPath.getSegmentsList());
+ for (Name segmentName : segmentNames) {
+ if (segmentName == null) {
+ ArgCheck.containsNoNulls(segmentNames, "segment names");
+ }
+ segments.add(new BasicPathSegment(segmentName));
+ }
+ return new BasicPath(segments, parentPath.isAbsolute());
+ }
- /**
- * {@inheritDoc}
- */
- public Path create( Path parentPath,
- Segment... segments ) {
- ArgCheck.isNotNull(parentPath, "parent path");
- if (segments == null || segments.length == 0) return BasicPath.ROOT;
+ /**
+ * {@inheritDoc}
+ */
+ public Path create( Path parentPath, Segment... segments ) {
+ ArgCheck.isNotNull(parentPath, "parent path");
+ if (segments == null || segments.length == 0) return BasicPath.ROOT;
- List<Segment> segmentsList = new ArrayList<Segment>(parentPath.size() + 1);
- segmentsList.addAll(parentPath.getSegmentsList());
- for (Segment segment : segments) {
- if (segment == null) {
- ArgCheck.containsNoNulls(segments, "segments");
- }
- segmentsList.add(segment);
- }
- return new BasicPath(segmentsList, parentPath.isAbsolute());
- }
+ List<Segment> segmentsList = new ArrayList<Segment>(parentPath.size() + 1);
+ segmentsList.addAll(parentPath.getSegmentsList());
+ for (Segment segment : segments) {
+ if (segment == null) {
+ ArgCheck.containsNoNulls(segments, "segments");
+ }
+ segmentsList.add(segment);
+ }
+ return new BasicPath(segmentsList, parentPath.isAbsolute());
+ }
- /**
- * {@inheritDoc}
- */
- public Segment createSegment( Name segmentName ) {
- ArgCheck.isNotNull(segmentName, "segment name");
- if (Path.SELF_NAME.equals(segmentName)) return Path.SELF_SEGMENT;
- if (Path.PARENT_NAME.equals(segmentName)) return Path.PARENT_SEGMENT;
- return new BasicPathSegment(segmentName);
- }
+ /**
+ * {@inheritDoc}
+ */
+ public Segment createSegment( Name segmentName ) {
+ ArgCheck.isNotNull(segmentName, "segment name");
+ if (Path.SELF_NAME.equals(segmentName)) return Path.SELF_SEGMENT;
+ if (Path.PARENT_NAME.equals(segmentName)) return Path.PARENT_SEGMENT;
+ return new BasicPathSegment(segmentName);
+ }
- /**
- * {@inheritDoc}
- */
- public Segment createSegment( Name segmentName,
- int index ) {
- ArgCheck.isNotNull(segmentName, "segment name");
- if (Path.SELF_NAME.equals(segmentName)) return Path.SELF_SEGMENT;
- if (Path.PARENT_NAME.equals(segmentName)) return Path.PARENT_SEGMENT;
- return new BasicPathSegment(segmentName, index);
- }
+ /**
+ * {@inheritDoc}
+ */
+ public Segment createSegment( Name segmentName, int index ) {
+ ArgCheck.isNotNull(segmentName, "segment name");
+ if (Path.SELF_NAME.equals(segmentName)) return Path.SELF_SEGMENT;
+ if (Path.PARENT_NAME.equals(segmentName)) return Path.PARENT_SEGMENT;
+ return new BasicPathSegment(segmentName, index);
+ }
- /**
- * {@inheritDoc}
- *
- * @see org.jboss.dna.spi.graph.PathFactory#createSegment(java.lang.String)
- */
- public Segment createSegment( String segmentName ) {
- return createSegment(segmentName, getEncoder());
- }
+ /**
+ * {@inheritDoc}
+ *
+ * @see org.jboss.dna.spi.graph.PathFactory#createSegment(java.lang.String)
+ */
+ public Segment createSegment( String segmentName ) {
+ return createSegment(segmentName, getDecoder());
+ }
- /**
- * <p>
- * {@inheritDoc}
- * </p>
- *
- * @see org.jboss.dna.spi.graph.PathFactory#createSegment(java.lang.String, org.jboss.dna.common.text.TextEncoder)
- */
- public Segment createSegment( String segmentName,
- TextEncoder encoder ) {
- ArgCheck.isNotNull(segmentName, "segment name");
- if (Path.SELF.equals(segmentName)) return Path.SELF_SEGMENT;
- if (Path.PARENT.equals(segmentName)) return Path.PARENT_SEGMENT;
- int startBracketNdx = segmentName.indexOf('[');
- if (startBracketNdx < 0) {
- return new BasicPathSegment(this.nameValueFactory.create(segmentName));
- }
- int endBracketNdx = segmentName.indexOf(']', startBracketNdx);
- if (endBracketNdx < 0) {
- throw new IllegalArgumentException(SpiI18n.missingEndBracketInSegmentName.text(segmentName));
- }
- String ndx = segmentName.substring(startBracketNdx + 1, endBracketNdx);
- try {
- return new BasicPathSegment(this.nameValueFactory.create(segmentName.substring(0, startBracketNdx)),
- Integer.parseInt(ndx));
- } catch (NumberFormatException err) {
- throw new IllegalArgumentException(SpiI18n.invalidIndexInSegmentName.text(ndx, segmentName));
- }
- }
+ /**
+ * <p>
+ * {@inheritDoc}
+ * </p>
+ *
+ * @see org.jboss.dna.spi.graph.PathFactory#createSegment(java.lang.String, org.jboss.dna.common.text.TextDecoder)
+ */
+ public Segment createSegment( String segmentName, TextDecoder decoder ) {
+ ArgCheck.isNotNull(segmentName, "segment name");
+ if (Path.SELF.equals(segmentName)) return Path.SELF_SEGMENT;
+ if (Path.PARENT.equals(segmentName)) return Path.PARENT_SEGMENT;
+ int startBracketNdx = segmentName.indexOf('[');
+ if (startBracketNdx < 0) {
+ return new BasicPathSegment(this.nameValueFactory.create(segmentName, decoder));
+ }
+ int endBracketNdx = segmentName.indexOf(']', startBracketNdx);
+ if (endBracketNdx < 0) {
+ throw new IllegalArgumentException(SpiI18n.missingEndBracketInSegmentName.text(segmentName));
+ }
+ String ndx = segmentName.substring(startBracketNdx + 1, endBracketNdx);
+ try {
+ return new BasicPathSegment(this.nameValueFactory.create(segmentName.substring(0, startBracketNdx), decoder), Integer.parseInt(ndx));
+ } catch (NumberFormatException err) {
+ throw new IllegalArgumentException(SpiI18n.invalidIndexInSegmentName.text(ndx, segmentName));
+ }
+ }
- /**
- * {@inheritDoc}
- */
- public Segment createSegment( String segmentName,
- int index ) {
- ArgCheck.isNotNull(segmentName, "segment name");
- if (Path.SELF.equals(segmentName)) return Path.SELF_SEGMENT;
- if (Path.PARENT.equals(segmentName)) return Path.PARENT_SEGMENT;
- return new BasicPathSegment(this.nameValueFactory.create(segmentName), index);
- }
+ /**
+ * {@inheritDoc}
+ */
+ public Segment createSegment( String segmentName, int index ) {
+ ArgCheck.isNotNull(segmentName, "segment name");
+ if (Path.SELF.equals(segmentName)) return Path.SELF_SEGMENT;
+ if (Path.PARENT.equals(segmentName)) return Path.PARENT_SEGMENT;
+ return new BasicPathSegment(this.nameValueFactory.create(segmentName), index);
+ }
- /**
- * {@inheritDoc}
- */
- public Path create( Reference value ) throws ValueFormatException {
- throw new ValueFormatException(SpiI18n.unableToCreateValue.text(getPropertyType().getName(),
- Reference.class.getSimpleName(),
- value));
- }
+ /**
+ * {@inheritDoc}
+ */
+ public Path create( Reference value ) throws ValueFormatException {
+ throw new ValueFormatException(SpiI18n.unableToCreateValue.text(getPropertyType().getName(), Reference.class.getSimpleName(), value));
+ }
- /**
- * {@inheritDoc}
- */
- public Path create( URI value ) throws ValueFormatException {
- if (value == null) return null;
- String asciiString = value.toASCIIString();
- // Remove any leading "./" ...
- if (asciiString.startsWith("./") && asciiString.length() > 2) {
- asciiString = asciiString.substring(2);
- }
- if (asciiString.indexOf('/') == -1) {
- return create(asciiString);
- }
- throw new ValueFormatException(SpiI18n.errorCreatingValue.text(getPropertyType().getName(),
- Path.class.getSimpleName(),
- value));
- }
+ /**
+ * {@inheritDoc}
+ */
+ public Path create( URI value ) throws ValueFormatException {
+ if (value == null) return null;
+ String asciiString = value.toASCIIString();
+ // Remove any leading "./" ...
+ if (asciiString.startsWith("./") && asciiString.length() > 2) {
+ asciiString = asciiString.substring(2);
+ }
+ if (asciiString.indexOf('/') == -1) {
+ return create(asciiString);
+ }
+ throw new ValueFormatException(SpiI18n.errorCreatingValue.text(getPropertyType().getName(), Path.class.getSimpleName(), value));
+ }
- /**
- * {@inheritDoc}
- */
- public Path create( byte[] value ) throws ValueFormatException {
- // First attempt to create a string from the value, then a long from the string ...
- return create(getStringValueFactory().create(value));
- }
+ /**
+ * {@inheritDoc}
+ */
+ public Path create( byte[] value ) throws ValueFormatException {
+ // First attempt to create a string from the value, then a long from the string ...
+ return create(getStringValueFactory().create(value));
+ }
- /**
- * {@inheritDoc}
- */
- public Path create( InputStream stream,
- int approximateLength ) throws IOException, ValueFormatException {
- // First attempt to create a string from the value, then a double from the string ...
- return create(getStringValueFactory().create(stream, approximateLength));
- }
+ /**
+ * {@inheritDoc}
+ */
+ public Path create( InputStream stream, int approximateLength ) throws IOException, ValueFormatException {
+ // First attempt to create a string from the value, then a double from the string ...
+ return create(getStringValueFactory().create(stream, approximateLength));
+ }
- /**
- * {@inheritDoc}
- */
- public Path create( Reader reader,
- int approximateLength ) throws IOException, ValueFormatException {
- // First attempt to create a string from the value, then a double from the string ...
- return create(getStringValueFactory().create(reader, approximateLength));
- }
+ /**
+ * {@inheritDoc}
+ */
+ public Path create( Reader reader, int approximateLength ) throws IOException, ValueFormatException {
+ // First attempt to create a string from the value, then a double from the string ...
+ return create(getStringValueFactory().create(reader, approximateLength));
+ }
}
Modified: trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/StandardValueFactories.java
===================================================================
--- trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/StandardValueFactories.java 2008-06-02 20:19:51 UTC (rev 234)
+++ trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/StandardValueFactories.java 2008-06-03 17:32:57 UTC (rev 235)
@@ -28,6 +28,7 @@
import java.util.Iterator;
import java.util.Map;
import net.jcip.annotations.Immutable;
+import org.jboss.dna.common.text.TextDecoder;
import org.jboss.dna.common.text.TextEncoder;
import org.jboss.dna.common.util.ArgCheck;
import org.jboss.dna.spi.graph.Binary;
@@ -42,6 +43,7 @@
/**
* The standard set of {@link ValueFactory value factories}.
+ *
* @author Randall Hauch
*/
@Immutable
@@ -63,28 +65,33 @@
private final Map<PropertyType, ValueFactory<?>> factories;
private final NamespaceRegistry namespaceRegistry;
+ private final TextDecoder decoder;
private final TextEncoder encoder;
/**
- * Create a standard set of value factories, using the {@link ValueFactory#DEFAULT_ENCODER default encoder/decoder}.
+ * Create a standard set of value factories, using the {@link ValueFactory#DEFAULT_DECODER default decoder}.
+ *
* @param namespaceRegistry the namespace registry
* @throws IllegalArgumentException if the namespace registry is null
*/
public StandardValueFactories( NamespaceRegistry namespaceRegistry ) {
- this(namespaceRegistry, null);
+ this(namespaceRegistry, null, null);
}
/**
* Create a standard set of value factories, using the supplied encoder/decoder.
+ *
* @param namespaceRegistry the namespace registry
+ * @param decoder the decoder that should be used; if null, the {@link ValueFactory#DEFAULT_DECODER default decoder} is used.
* @param encoder the encoder that should be used; if null, the {@link ValueFactory#DEFAULT_ENCODER default encoder} is used.
* @param extraFactories any extra factories that should be used; any factory will override the standard factories based upon
* the {@link ValueFactory#getPropertyType() factory's property type}.
* @throws IllegalArgumentException if the namespace registry is null
*/
- public StandardValueFactories( NamespaceRegistry namespaceRegistry, TextEncoder encoder, ValueFactory<?>... extraFactories ) {
+ public StandardValueFactories( NamespaceRegistry namespaceRegistry, TextDecoder decoder, TextEncoder encoder, ValueFactory<?>... extraFactories ) {
ArgCheck.isNotNull(namespaceRegistry, "namespaceRegistry");
this.namespaceRegistry = namespaceRegistry;
+ this.decoder = decoder != null ? decoder : ValueFactory.DEFAULT_DECODER;
this.encoder = encoder != null ? encoder : ValueFactory.DEFAULT_ENCODER;
Map<PropertyType, ValueFactory<?>> factories = new HashMap<PropertyType, ValueFactory<?>>();
@@ -95,18 +102,18 @@
}
// Now assign the members, using the factories in the map or (if null) the supplied default ...
- this.stringFactory = getFactory(factories, new StringValueFactory(this.encoder));
- this.binaryFactory = getFactory(factories, new InMemoryBinaryValueFactory(this.encoder, this.stringFactory));
- this.booleanFactory = getFactory(factories, new BooleanValueFactory(this.encoder, this.stringFactory));
- this.dateFactory = (DateTimeFactory)getFactory(factories, new JodaDateTimeValueFactory(this.encoder, this.stringFactory));
- this.decimalFactory = getFactory(factories, new DecimalValueFactory(this.encoder, this.stringFactory));
- this.doubleFactory = getFactory(factories, new DoubleValueFactory(this.encoder, this.stringFactory));
- this.longFactory = getFactory(factories, new LongValueFactory(this.encoder, this.stringFactory));
- this.nameFactory = (NameFactory)getFactory(factories, new NameValueFactory(this.namespaceRegistry, this.encoder, this.stringFactory));
- this.pathFactory = (PathFactory)getFactory(factories, new PathValueFactory(this.encoder, this.stringFactory, this.nameFactory));
- this.referenceFactory = getFactory(factories, new UuidReferenceValueFactory(this.encoder, this.stringFactory));
- this.uriFactory = getFactory(factories, new UriValueFactory(this.namespaceRegistry, this.encoder, this.stringFactory));
- this.objectFactory = getFactory(factories, new ObjectValueFactory(this.encoder, this.stringFactory, this.binaryFactory));
+ this.stringFactory = getFactory(factories, new StringValueFactory(this.decoder, this.encoder));
+ this.binaryFactory = getFactory(factories, new InMemoryBinaryValueFactory(this.decoder, this.stringFactory));
+ this.booleanFactory = getFactory(factories, new BooleanValueFactory(this.decoder, this.stringFactory));
+ this.dateFactory = (DateTimeFactory)getFactory(factories, new JodaDateTimeValueFactory(this.decoder, this.stringFactory));
+ this.decimalFactory = getFactory(factories, new DecimalValueFactory(this.decoder, this.stringFactory));
+ this.doubleFactory = getFactory(factories, new DoubleValueFactory(this.decoder, this.stringFactory));
+ this.longFactory = getFactory(factories, new LongValueFactory(this.decoder, this.stringFactory));
+ this.nameFactory = (NameFactory)getFactory(factories, new NameValueFactory(this.namespaceRegistry, this.decoder, this.stringFactory));
+ this.pathFactory = (PathFactory)getFactory(factories, new PathValueFactory(this.decoder, this.stringFactory, this.nameFactory));
+ this.referenceFactory = getFactory(factories, new UuidReferenceValueFactory(this.decoder, this.stringFactory));
+ this.uriFactory = getFactory(factories, new UriValueFactory(this.namespaceRegistry, this.decoder, this.stringFactory));
+ this.objectFactory = getFactory(factories, new ObjectValueFactory(this.decoder, this.stringFactory, this.binaryFactory));
// Wrap the factories with an unmodifiable ...
this.factories = Collections.unmodifiableMap(factories);
@@ -124,10 +131,10 @@
}
/**
- * @return encoder
+ * @return decoder
*/
- public TextEncoder getTextEncoder() {
- return this.encoder;
+ public TextDecoder getTextDecoder() {
+ return this.decoder;
}
/**
Modified: trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/StringValueFactory.java
===================================================================
--- trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/StringValueFactory.java 2008-06-02 20:19:51 UTC (rev 234)
+++ trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/StringValueFactory.java 2008-06-03 17:32:57 UTC (rev 235)
@@ -30,7 +30,9 @@
import java.util.Calendar;
import java.util.Date;
import net.jcip.annotations.Immutable;
+import org.jboss.dna.common.text.TextDecoder;
import org.jboss.dna.common.text.TextEncoder;
+import org.jboss.dna.common.util.ArgCheck;
import org.jboss.dna.common.util.IoUtil;
import org.jboss.dna.spi.SpiI18n;
import org.jboss.dna.spi.graph.Name;
@@ -42,16 +44,28 @@
/**
* The standard {@link ValueFactory} for {@link PropertyType#STRING} values.
+ *
* @author Randall Hauch
*/
@Immutable
public class StringValueFactory extends AbstractValueFactory<String> {
- public StringValueFactory( TextEncoder encoder ) {
- super(PropertyType.STRING, encoder, null);
+ private final TextEncoder encoder;
+
+ public StringValueFactory( TextDecoder decoder, TextEncoder encoder ) {
+ super(PropertyType.STRING, decoder, null);
+ ArgCheck.isNotNull(encoder, "encoder");
+ this.encoder = encoder;
}
/**
+ * @return encoder
+ */
+ public TextEncoder getEncoder() {
+ return this.encoder;
+ }
+
+ /**
* {@inheritDoc}
*/
@Override
@@ -69,9 +83,9 @@
/**
* {@inheritDoc}
*/
- public String create( String value, TextEncoder decoder ) {
+ public String create( String value, TextDecoder decoder ) {
if (value == null) return value;
- if (decoder == null) decoder = getEncoder();
+ if (decoder == null) decoder = getDecoder();
return decoder.decode(value);
}
Modified: trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/UriValueFactory.java
===================================================================
--- trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/UriValueFactory.java 2008-06-02 20:19:51 UTC (rev 234)
+++ trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/UriValueFactory.java 2008-06-03 17:32:57 UTC (rev 235)
@@ -30,7 +30,7 @@
import java.util.Calendar;
import java.util.Date;
import net.jcip.annotations.Immutable;
-import org.jboss.dna.common.text.TextEncoder;
+import org.jboss.dna.common.text.TextDecoder;
import org.jboss.dna.common.util.ArgCheck;
import org.jboss.dna.spi.SpiI18n;
import org.jboss.dna.spi.graph.Name;
@@ -43,6 +43,7 @@
/**
* The standard {@link ValueFactory} for {@link PropertyType#URI} values.
+ *
* @author Randall Hauch
*/
@Immutable
@@ -50,8 +51,8 @@
private final NamespaceRegistry namespaceRegistry;
- public UriValueFactory( NamespaceRegistry namespaceRegistry, TextEncoder encoder, ValueFactory<String> stringValueFactory ) {
- super(PropertyType.URI, encoder, stringValueFactory);
+ public UriValueFactory( NamespaceRegistry namespaceRegistry, TextDecoder decoder, ValueFactory<String> stringValueFactory ) {
+ super(PropertyType.URI, decoder, stringValueFactory);
ArgCheck.isNotNull(namespaceRegistry, "namespaceRegistry");
this.namespaceRegistry = namespaceRegistry;
}
@@ -71,9 +72,9 @@
/**
* {@inheritDoc}
*/
- public URI create( String value, TextEncoder decoder ) {
+ public URI create( String value, TextDecoder decoder ) {
// this probably doesn't really need to call the decoder, but by doing so then we don't care at all what the decoder does
- return create(getEncoder(decoder).decode(value));
+ return create(getDecoder(decoder).decode(value));
}
/**
Modified: trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/UuidReferenceValueFactory.java
===================================================================
--- trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/UuidReferenceValueFactory.java 2008-06-02 20:19:51 UTC (rev 234)
+++ trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/UuidReferenceValueFactory.java 2008-06-03 17:32:57 UTC (rev 235)
@@ -30,7 +30,7 @@
import java.util.Date;
import java.util.UUID;
import net.jcip.annotations.Immutable;
-import org.jboss.dna.common.text.TextEncoder;
+import org.jboss.dna.common.text.TextDecoder;
import org.jboss.dna.spi.SpiI18n;
import org.jboss.dna.spi.graph.Name;
import org.jboss.dna.spi.graph.Path;
@@ -41,13 +41,14 @@
/**
* The standard {@link ValueFactory} for {@link PropertyType#REFERENCE} values.
+ *
* @author Randall Hauch
*/
@Immutable
public class UuidReferenceValueFactory extends AbstractValueFactory<Reference> {
- public UuidReferenceValueFactory( TextEncoder encoder, ValueFactory<String> stringValueFactory ) {
- super(PropertyType.REFERENCE, encoder, stringValueFactory);
+ public UuidReferenceValueFactory( TextDecoder decoder, ValueFactory<String> stringValueFactory ) {
+ super(PropertyType.REFERENCE, decoder, stringValueFactory);
}
/**
@@ -66,9 +67,9 @@
/**
* {@inheritDoc}
*/
- public Reference create( String value, TextEncoder decoder ) {
+ public Reference create( String value, TextDecoder decoder ) {
// this probably doesn't really need to call the decoder, but by doing so then we don't care at all what the decoder does
- return create(getEncoder(decoder).decode(value));
+ return create(getDecoder(decoder).decode(value));
}
/**
Modified: trunk/dna-spi/src/test/java/org/jboss/dna/spi/graph/impl/AbstractValueFactoryTest.java
===================================================================
--- trunk/dna-spi/src/test/java/org/jboss/dna/spi/graph/impl/AbstractValueFactoryTest.java 2008-06-02 20:19:51 UTC (rev 234)
+++ trunk/dna-spi/src/test/java/org/jboss/dna/spi/graph/impl/AbstractValueFactoryTest.java 2008-06-03 17:32:57 UTC (rev 235)
@@ -33,7 +33,7 @@
import java.util.Calendar;
import java.util.Date;
import org.jboss.dna.common.text.NoOpEncoder;
-import org.jboss.dna.common.text.TextEncoder;
+import org.jboss.dna.common.text.TextDecoder;
import org.jboss.dna.spi.graph.Name;
import org.jboss.dna.spi.graph.Path;
import org.jboss.dna.spi.graph.PropertyType;
@@ -48,19 +48,19 @@
*/
public class AbstractValueFactoryTest {
- public static final TextEncoder CUSTOM_ENCODER = new NoOpEncoder();
+ public static final TextDecoder CUSTOM_DECODER = new NoOpEncoder();
private static class MockFactory extends AbstractValueFactory<String> {
- protected MockFactory( TextEncoder encoder, StringValueFactory stringValueFactory ) {
- super(PropertyType.STRING, encoder, stringValueFactory);
+ protected MockFactory( TextDecoder decoder, StringValueFactory stringValueFactory ) {
+ super(PropertyType.STRING, decoder, stringValueFactory);
}
public String create( String value ) throws ValueFormatException {
return null;
}
- public String create( String value, TextEncoder decoder ) throws ValueFormatException {
+ public String create( String value, TextDecoder decoder ) throws ValueFormatException {
return null;
}
@@ -134,29 +134,29 @@
@Test
public void shouldHaveDefaultEncoderIfNullPassedIntoConstructor() {
- assertThat(factory.getEncoder(), is(notNullValue()));
- assertThat(factory.getEncoder(), is(sameInstance(ValueFactory.DEFAULT_ENCODER)));
+ assertThat(factory.getDecoder(), is(notNullValue()));
+ assertThat(factory.getDecoder(), is(sameInstance(ValueFactory.DEFAULT_DECODER)));
}
@Test
public void shouldReturnTextEncoderPassedIntoConstructor() {
- factory = new MockFactory(CUSTOM_ENCODER, null);
- assertThat(factory.getEncoder(), is(notNullValue()));
- assertThat(factory.getEncoder(), is(sameInstance(CUSTOM_ENCODER)));
+ factory = new MockFactory(CUSTOM_DECODER, null);
+ assertThat(factory.getDecoder(), is(notNullValue()));
+ assertThat(factory.getDecoder(), is(sameInstance(CUSTOM_DECODER)));
}
@Test
public void shouldReturnDefaultTextEncoderWhenNullPassedToGetEncoder() {
- assertThat(factory.getEncoder(), is(sameInstance(ValueFactory.DEFAULT_ENCODER)));
- assertThat(factory.getEncoder(null), is(sameInstance(ValueFactory.DEFAULT_ENCODER)));
- assertThat(factory.getEncoder(CUSTOM_ENCODER), is(sameInstance(CUSTOM_ENCODER)));
+ assertThat(factory.getDecoder(), is(sameInstance(ValueFactory.DEFAULT_DECODER)));
+ assertThat(factory.getDecoder(null), is(sameInstance(ValueFactory.DEFAULT_DECODER)));
+ assertThat(factory.getDecoder(CUSTOM_DECODER), is(sameInstance(CUSTOM_DECODER)));
}
@Test
public void shouldReturnSuppliedTextEncoderWhenNonNullPassedToGetEncoder() {
- assertThat(factory.getEncoder(), is(sameInstance(ValueFactory.DEFAULT_ENCODER)));
- assertThat(factory.getEncoder(null), is(sameInstance(ValueFactory.DEFAULT_ENCODER)));
- assertThat(factory.getEncoder(CUSTOM_ENCODER), is(sameInstance(CUSTOM_ENCODER)));
+ assertThat(factory.getDecoder(), is(sameInstance(ValueFactory.DEFAULT_DECODER)));
+ assertThat(factory.getDecoder(null), is(sameInstance(ValueFactory.DEFAULT_DECODER)));
+ assertThat(factory.getDecoder(CUSTOM_DECODER), is(sameInstance(CUSTOM_DECODER)));
}
@Test
Modified: trunk/dna-spi/src/test/java/org/jboss/dna/spi/graph/impl/BasicPathSegmentTest.java
===================================================================
--- trunk/dna-spi/src/test/java/org/jboss/dna/spi/graph/impl/BasicPathSegmentTest.java 2008-06-02 20:19:51 UTC (rev 234)
+++ trunk/dna-spi/src/test/java/org/jboss/dna/spi/graph/impl/BasicPathSegmentTest.java 2008-06-03 17:32:57 UTC (rev 235)
@@ -41,7 +41,6 @@
private ValueFactory<String> stringValueFactory;
private NameValueFactory nameFactory;
private PathValueFactory factory;
- private TextEncoder encoder;
private Name validName;
private Path.Segment segment;
private Path.Segment segment2;
@@ -50,11 +49,10 @@
public void beforeEach() throws Exception {
this.registry = new BasicNamespaceRegistry();
this.registry.register("dna", "http://www.jboss.org/dna/namespace");
- this.encoder = Path.DEFAULT_ENCODER;
- this.stringValueFactory = new StringValueFactory(encoder);
- this.nameFactory = new NameValueFactory(registry, encoder, stringValueFactory);
+ this.stringValueFactory = new StringValueFactory(Path.DEFAULT_DECODER, Path.DEFAULT_ENCODER);
+ this.nameFactory = new NameValueFactory(registry, Path.DEFAULT_DECODER, stringValueFactory);
this.validName = nameFactory.create("dna:something");
- this.factory = new PathValueFactory(encoder, stringValueFactory, nameFactory);
+ this.factory = new PathValueFactory(Path.DEFAULT_DECODER, stringValueFactory, nameFactory);
}
@Test( expected = IllegalArgumentException.class )
Modified: trunk/dna-spi/src/test/java/org/jboss/dna/spi/graph/impl/BasicPathTest.java
===================================================================
--- trunk/dna-spi/src/test/java/org/jboss/dna/spi/graph/impl/BasicPathTest.java 2008-06-02 20:19:51 UTC (rev 234)
+++ trunk/dna-spi/src/test/java/org/jboss/dna/spi/graph/impl/BasicPathTest.java 2008-06-03 17:32:57 UTC (rev 235)
@@ -46,731 +46,718 @@
*/
public class BasicPathTest {
- public static final TextEncoder NO_OP_ENCODER = Path.NO_OP_ENCODER;
- public static final Path ROOT = BasicPath.ROOT;
+ public static final TextEncoder NO_OP_ENCODER = Path.NO_OP_ENCODER;
+ public static final Path ROOT = BasicPath.ROOT;
- private BasicNamespaceRegistry namespaceRegistry;
- private String validNamespaceUri;
- private Path path;
- private Path path2;
- private Path.Segment[] validSegments;
- private List<Path.Segment> validSegmentsList;
- private Name[] validSegmentNames;
- private String validNamespacePrefix;
- private PathValueFactory pathFactory;
+ private BasicNamespaceRegistry namespaceRegistry;
+ private String validNamespaceUri;
+ private Path path;
+ private Path path2;
+ private Path.Segment[] validSegments;
+ private List<Path.Segment> validSegmentsList;
+ private Name[] validSegmentNames;
+ private String validNamespacePrefix;
+ private PathValueFactory pathFactory;
- @Before
- public void beforeEach() throws Exception {
- validNamespacePrefix = "dna";
- validNamespaceUri = "http://www.jboss.org/dna";
- validSegmentNames = new Name[] {new BasicName(validNamespaceUri, "a"), new BasicName(validNamespaceUri, "b"),
- new BasicName(validNamespaceUri, "c")};
- validSegments = new Path.Segment[] {new BasicPathSegment(validSegmentNames[0]),
- new BasicPathSegment(validSegmentNames[1]), new BasicPathSegment(validSegmentNames[1])};
- validSegmentsList = new ArrayList<Path.Segment>();
- for (Path.Segment segment : validSegments) {
- validSegmentsList.add(segment);
- }
- path = new BasicPath(validSegmentsList, true);
- namespaceRegistry = new BasicNamespaceRegistry();
- namespaceRegistry.register(validNamespacePrefix, validNamespaceUri);
- StringValueFactory stringValueFactory = new StringValueFactory(Path.DEFAULT_ENCODER);
- NameValueFactory nameValueFactory = new NameValueFactory(namespaceRegistry, Path.DEFAULT_ENCODER, stringValueFactory);
- pathFactory = new PathValueFactory(Path.DEFAULT_ENCODER, stringValueFactory, nameValueFactory);
- }
+ @Before
+ public void beforeEach() throws Exception {
+ validNamespacePrefix = "dna";
+ validNamespaceUri = "http://www.jboss.org/dna";
+ validSegmentNames = new Name[] {new BasicName(validNamespaceUri, "a"), new BasicName(validNamespaceUri, "b"), new BasicName(validNamespaceUri, "c")};
+ validSegments = new Path.Segment[] {new BasicPathSegment(validSegmentNames[0]), new BasicPathSegment(validSegmentNames[1]), new BasicPathSegment(validSegmentNames[1])};
+ validSegmentsList = new ArrayList<Path.Segment>();
+ for (Path.Segment segment : validSegments) {
+ validSegmentsList.add(segment);
+ }
+ path = new BasicPath(validSegmentsList, true);
+ namespaceRegistry = new BasicNamespaceRegistry();
+ namespaceRegistry.register(validNamespacePrefix, validNamespaceUri);
+ StringValueFactory stringValueFactory = new StringValueFactory(Path.DEFAULT_DECODER, Path.DEFAULT_ENCODER);
+ NameValueFactory nameValueFactory = new NameValueFactory(namespaceRegistry, Path.DEFAULT_DECODER, stringValueFactory);
+ pathFactory = new PathValueFactory(Path.DEFAULT_DECODER, stringValueFactory, nameValueFactory);
+ }
- @Test
- public void shouldCreateAbsolutePathFromListOfValidSegments() {
- path = new BasicPath(validSegmentsList, true);
- assertThat(path.isAbsolute(), is(true));
- assertThat(path.isNormalized(), is(true));
- assertThat(path.getSegmentsList(), is(validSegmentsList));
- assertThat(path.size(), is(validSegmentsList.size()));
- }
+ @Test
+ public void shouldCreateAbsolutePathFromListOfValidSegments() {
+ path = new BasicPath(validSegmentsList, true);
+ assertThat(path.isAbsolute(), is(true));
+ assertThat(path.isNormalized(), is(true));
+ assertThat(path.getSegmentsList(), is(validSegmentsList));
+ assertThat(path.size(), is(validSegmentsList.size()));
+ }
- @Test
- public void shouldCreateRelativePathFromListOfValidSegments() {
- path = new BasicPath(validSegmentsList, false);
- assertThat(path.isAbsolute(), is(false));
- assertThat(path.isNormalized(), is(true));
- assertThat(path.getSegmentsList(), is(validSegmentsList));
- assertThat(path.size(), is(validSegmentsList.size()));
- }
+ @Test
+ public void shouldCreateRelativePathFromListOfValidSegments() {
+ path = new BasicPath(validSegmentsList, false);
+ assertThat(path.isAbsolute(), is(false));
+ assertThat(path.isNormalized(), is(true));
+ assertThat(path.getSegmentsList(), is(validSegmentsList));
+ assertThat(path.size(), is(validSegmentsList.size()));
+ }
- @Test
- public void shouldCreateAbsolutePathWithParentSegment() {
- validSegmentsList.add(Path.PARENT_SEGMENT);
- path = new BasicPath(validSegmentsList, true);
- assertThat(path.isAbsolute(), is(true));
- assertThat(path.isNormalized(), is(false));
- assertThat(path.getSegmentsList(), is(validSegmentsList));
- assertThat(path.size(), is(validSegmentsList.size()));
- }
+ @Test
+ public void shouldCreateAbsolutePathWithParentSegment() {
+ validSegmentsList.add(Path.PARENT_SEGMENT);
+ path = new BasicPath(validSegmentsList, true);
+ assertThat(path.isAbsolute(), is(true));
+ assertThat(path.isNormalized(), is(false));
+ assertThat(path.getSegmentsList(), is(validSegmentsList));
+ assertThat(path.size(), is(validSegmentsList.size()));
+ }
- @Test
- public void shouldCreateRelativePathWithParentSegment() {
- validSegmentsList.add(Path.PARENT_SEGMENT);
- path = new BasicPath(validSegmentsList, false);
- assertThat(path.isAbsolute(), is(false));
- assertThat(path.isNormalized(), is(false));
- assertThat(path.getSegmentsList(), is(validSegmentsList));
- assertThat(path.size(), is(validSegmentsList.size()));
- }
+ @Test
+ public void shouldCreateRelativePathWithParentSegment() {
+ validSegmentsList.add(Path.PARENT_SEGMENT);
+ path = new BasicPath(validSegmentsList, false);
+ assertThat(path.isAbsolute(), is(false));
+ assertThat(path.isNormalized(), is(false));
+ assertThat(path.getSegmentsList(), is(validSegmentsList));
+ assertThat(path.size(), is(validSegmentsList.size()));
+ }
- @Test
- public void shouldCreateAbsolutePathWithSelfSegment() {
- validSegmentsList.add(Path.SELF_SEGMENT);
- path = new BasicPath(validSegmentsList, true);
- assertThat(path.isAbsolute(), is(true));
- assertThat(path.isNormalized(), is(false));
- assertThat(path.getSegmentsList(), is(validSegmentsList));
- assertThat(path.size(), is(validSegmentsList.size()));
- }
+ @Test
+ public void shouldCreateAbsolutePathWithSelfSegment() {
+ validSegmentsList.add(Path.SELF_SEGMENT);
+ path = new BasicPath(validSegmentsList, true);
+ assertThat(path.isAbsolute(), is(true));
+ assertThat(path.isNormalized(), is(false));
+ assertThat(path.getSegmentsList(), is(validSegmentsList));
+ assertThat(path.size(), is(validSegmentsList.size()));
+ }
- @Test
- public void shouldCreateRelativePathWithSelfSegment() {
- validSegmentsList.add(Path.SELF_SEGMENT);
- path = new BasicPath(validSegmentsList, false);
- assertThat(path.isAbsolute(), is(false));
- assertThat(path.isNormalized(), is(false));
- assertThat(path.getSegmentsList(), is(validSegmentsList));
- assertThat(path.size(), is(validSegmentsList.size()));
- }
+ @Test
+ public void shouldCreateRelativePathWithSelfSegment() {
+ validSegmentsList.add(Path.SELF_SEGMENT);
+ path = new BasicPath(validSegmentsList, false);
+ assertThat(path.isAbsolute(), is(false));
+ assertThat(path.isNormalized(), is(false));
+ assertThat(path.getSegmentsList(), is(validSegmentsList));
+ assertThat(path.size(), is(validSegmentsList.size()));
+ }
- @Test
- public void shouldCreatePathWithNoNamespacePrefixes() {
- path = pathFactory.create("/a/b/c/");
- assertThat(path.size(), is(3));
- assertThat(path, hasSegments(pathFactory, "a", "b", "c"));
- }
+ @Test
+ public void shouldCreatePathWithNoNamespacePrefixes() {
+ path = pathFactory.create("/a/b/c/");
+ assertThat(path.size(), is(3));
+ assertThat(path, hasSegments(pathFactory, "a", "b", "c"));
+ }
- @Test
- public void shouldConstructRelativePath() {
- assertThat(pathFactory.create("a/b/c").isAbsolute(), is(false));
- assertThat(pathFactory.create("a/b/c").isNormalized(), is(true));
- assertThat(pathFactory.create("a/b/c").size(), is(3));
- assertThat(pathFactory.create("a/b/c").getString(namespaceRegistry), is("a/b/c"));
- }
+ @Test
+ public void shouldConstructRelativePath() {
+ assertThat(pathFactory.create("a/b/c").isAbsolute(), is(false));
+ assertThat(pathFactory.create("a/b/c").isNormalized(), is(true));
+ assertThat(pathFactory.create("a/b/c").size(), is(3));
+ assertThat(pathFactory.create("a/b/c").getString(namespaceRegistry), is("a/b/c"));
+ }
- @Test
- public void shouldConstructRelativePathToSelf() {
- assertThat(pathFactory.create(".").isAbsolute(), is(false));
- assertThat(pathFactory.create(".").size(), is(1));
- assertThat(pathFactory.create("."), hasSegments(pathFactory, Path.SELF));
+ @Test
+ public void shouldConstructRelativePathToSelf() {
+ assertThat(pathFactory.create(".").isAbsolute(), is(false));
+ assertThat(pathFactory.create(".").size(), is(1));
+ assertThat(pathFactory.create("."), hasSegments(pathFactory, Path.SELF));
- assertThat(pathFactory.create("./").isAbsolute(), is(false));
- assertThat(pathFactory.create("./").size(), is(1));
- assertThat(pathFactory.create("./"), hasSegments(pathFactory, Path.SELF));
- }
+ assertThat(pathFactory.create("./").isAbsolute(), is(false));
+ assertThat(pathFactory.create("./").size(), is(1));
+ assertThat(pathFactory.create("./"), hasSegments(pathFactory, Path.SELF));
+ }
- @Test
- public void shouldConstructRelativePathToParent() {
- assertThat(pathFactory.create("..").isAbsolute(), is(false));
- assertThat(pathFactory.create("..").size(), is(1));
- assertThat(pathFactory.create(".."), hasSegments(pathFactory, Path.PARENT));
+ @Test
+ public void shouldConstructRelativePathToParent() {
+ assertThat(pathFactory.create("..").isAbsolute(), is(false));
+ assertThat(pathFactory.create("..").size(), is(1));
+ assertThat(pathFactory.create(".."), hasSegments(pathFactory, Path.PARENT));
- assertThat(pathFactory.create("../").isAbsolute(), is(false));
- assertThat(pathFactory.create("../").size(), is(1));
- assertThat(pathFactory.create("../"), hasSegments(pathFactory, Path.PARENT));
- }
+ assertThat(pathFactory.create("../").isAbsolute(), is(false));
+ assertThat(pathFactory.create("../").size(), is(1));
+ assertThat(pathFactory.create("../"), hasSegments(pathFactory, Path.PARENT));
+ }
- @Test
- public void shouldConstructRootPathFromStringWithSingleDelimiter() {
- assertThat(pathFactory.create("/"), is(ROOT));
- assertThat(pathFactory.create("/").isRoot(), is(true));
- }
+ @Test
+ public void shouldConstructRootPathFromStringWithSingleDelimiter() {
+ assertThat(pathFactory.create("/"), is(ROOT));
+ assertThat(pathFactory.create("/").isRoot(), is(true));
+ }
- @Test( expected = ValueFormatException.class )
- public void shouldNotConstructPathWithSuccessiveDelimiters() {
- pathFactory.create("///a/b///c//d//");
- }
+ @Test( expected = ValueFormatException.class )
+ public void shouldNotConstructPathWithSuccessiveDelimiters() {
+ pathFactory.create("///a/b///c//d//");
+ }
- @Test( expected = ValueFormatException.class )
- public void shouldNotConstructPathWithOnlyDelimiters() {
- pathFactory.create("///");
- }
+ @Test( expected = ValueFormatException.class )
+ public void shouldNotConstructPathWithOnlyDelimiters() {
+ pathFactory.create("///");
+ }
- @Test( expected = IllegalArgumentException.class )
- public void shouldNotConstructPathFromNullList() {
- new BasicPath(null, true);
- }
+ @Test( expected = IllegalArgumentException.class )
+ public void shouldNotConstructPathFromNullList() {
+ new BasicPath(null, true);
+ }
- @Test
- public void shouldConstructPathFromStringAndShouldIgnoreLeadingAndTrailingWhitespace() {
- assertThat(pathFactory.create(" \t / \t").toString(), is("/"));
- }
+ @Test
+ public void shouldConstructPathFromStringAndShouldIgnoreLeadingAndTrailingWhitespace() {
+ assertThat(pathFactory.create(" \t / \t").toString(), is("/"));
+ }
- @Test
- public void shouldConstructRelativePathIfSuppliedPathHasNoLeadingDelimiter() {
- assertThat(pathFactory.create("a"), hasSegments(pathFactory, "a"));
- }
+ @Test
+ public void shouldConstructRelativePathIfSuppliedPathHasNoLeadingDelimiter() {
+ assertThat(pathFactory.create("a"), hasSegments(pathFactory, "a"));
+ }
- @Test
- public void shouldHaveSizeThatReflectsNumberOfSegments() {
- assertThat(path.size(), is(validSegmentsList.size()));
- }
+ @Test
+ public void shouldHaveSizeThatReflectsNumberOfSegments() {
+ assertThat(path.size(), is(validSegmentsList.size()));
+ }
- @Test
- public void shouldIterateOverAllSegmentsReturnedByList() {
- Iterator<Path.Segment> expectedIter = validSegmentsList.iterator();
- for (Path.Segment segment : path) {
- assertThat(segment, is(expectedIter.next()));
- }
+ @Test
+ public void shouldIterateOverAllSegmentsReturnedByList() {
+ Iterator<Path.Segment> expectedIter = validSegmentsList.iterator();
+ for (Path.Segment segment : path) {
+ assertThat(segment, is(expectedIter.next()));
+ }
- expectedIter = path.getSegmentsList().iterator();
- for (Path.Segment segment : path) {
- assertThat(segment, is(expectedIter.next()));
- }
- }
+ expectedIter = path.getSegmentsList().iterator();
+ for (Path.Segment segment : path) {
+ assertThat(segment, is(expectedIter.next()));
+ }
+ }
- @Test
- public void shouldReturnRootForAncestorOfRoot() {
- assertThat(BasicPath.ROOT.getAncestor(), is(ROOT));
- }
+ @Test
+ public void shouldReturnRootForAncestorOfRoot() {
+ assertThat(BasicPath.ROOT.getAncestor(), is(ROOT));
+ }
- @Test
- public void shouldReturnAncestorForNodeOtherThanRoot() {
- assertThat(path.getAncestor(), is(pathFactory.create("/dna:a/dna:b")));
- assertThat(path.getAncestor().getAncestor(), is(pathFactory.create("/dna:a")));
- assertThat(path.getAncestor().getAncestor().getAncestor(), is(ROOT));
- }
+ @Test
+ public void shouldReturnAncestorForNodeOtherThanRoot() {
+ assertThat(path.getAncestor(), is(pathFactory.create("/dna:a/dna:b")));
+ assertThat(path.getAncestor().getAncestor(), is(pathFactory.create("/dna:a")));
+ assertThat(path.getAncestor().getAncestor().getAncestor(), is(ROOT));
+ }
- @Test
- public void shouldReturnNthDegreeAncestor() {
- assertThat(path.getAncestor(1), is(pathFactory.create("/dna:a/dna:b")));
- assertThat(path.getAncestor(2), is(pathFactory.create("/dna:a")));
- assertThat(path.getAncestor(3), is(ROOT));
- }
+ @Test
+ public void shouldReturnNthDegreeAncestor() {
+ assertThat(path.getAncestor(1), is(pathFactory.create("/dna:a/dna:b")));
+ assertThat(path.getAncestor(2), is(pathFactory.create("/dna:a")));
+ assertThat(path.getAncestor(3), is(ROOT));
+ }
- @Test( expected = PathNotFoundException.class )
- public void shouldNotAllowAncestorDegreeLargerThanSize() {
- path.getAncestor(path.size() + 1);
- }
+ @Test( expected = PathNotFoundException.class )
+ public void shouldNotAllowAncestorDegreeLargerThanSize() {
+ path.getAncestor(path.size() + 1);
+ }
- @Test( expected = IllegalArgumentException.class )
- public void shouldNotAllowNegativeAncestorDegree() {
- path.getAncestor(-1);
- }
+ @Test( expected = IllegalArgumentException.class )
+ public void shouldNotAllowNegativeAncestorDegree() {
+ path.getAncestor(-1);
+ }
- @Test
- public void shouldReturnRootForAnyAncestorExactDegreeFromRoot() {
- assertThat(path.getAncestor(path.size()), is(ROOT));
- assertThat(ROOT.getAncestor(0), is(ROOT));
- }
+ @Test
+ public void shouldReturnRootForAnyAncestorExactDegreeFromRoot() {
+ assertThat(path.getAncestor(path.size()), is(ROOT));
+ assertThat(ROOT.getAncestor(0), is(ROOT));
+ }
- @Test
- public void shouldConsiderRootTheLowestCommonAncestorOfAnyNodeAndRoot() {
- assertThat(path.getCommonAncestor(ROOT), is(ROOT));
- assertThat(ROOT.getCommonAncestor(path), is(ROOT));
- }
+ @Test
+ public void shouldConsiderRootTheLowestCommonAncestorOfAnyNodeAndRoot() {
+ assertThat(path.getCommonAncestor(ROOT), is(ROOT));
+ assertThat(ROOT.getCommonAncestor(path), is(ROOT));
+ }
- @Test
- public void shouldReturnNullForLowestCommonAncestorWithNullPath() {
- assertThat(path.getCommonAncestor(null), is(nullValue()));
- }
+ @Test
+ public void shouldReturnNullForLowestCommonAncestorWithNullPath() {
+ assertThat(path.getCommonAncestor(null), is(nullValue()));
+ }
- @Test
- public void shouldFindLowestCommonAncestorBetweenTwoNonRootNodesOnCommonBranch() {
- Path path1 = pathFactory.create("/a/y/z");
- Path path2 = pathFactory.create("/a/b/c");
- Path common = pathFactory.create("/a");
- assertThat(path1.getCommonAncestor(path2), is(common));
+ @Test
+ public void shouldFindLowestCommonAncestorBetweenTwoNonRootNodesOnCommonBranch() {
+ Path path1 = pathFactory.create("/a/y/z");
+ Path path2 = pathFactory.create("/a/b/c");
+ Path common = pathFactory.create("/a");
+ assertThat(path1.getCommonAncestor(path2), is(common));
- path1 = pathFactory.create("/a/b/c");
- path2 = pathFactory.create("/a/b/c/d");
- common = path1;
- assertThat(path1.getCommonAncestor(path2), is(common));
+ path1 = pathFactory.create("/a/b/c");
+ path2 = pathFactory.create("/a/b/c/d");
+ common = path1;
+ assertThat(path1.getCommonAncestor(path2), is(common));
- path1 = pathFactory.create("/a/b/c/x/y/");
- path2 = pathFactory.create("/a/b/c/d/e/f/");
- common = pathFactory.create("/a/b/c");
- assertThat(path1.getCommonAncestor(path2), is(common));
- }
+ path1 = pathFactory.create("/a/b/c/x/y/");
+ path2 = pathFactory.create("/a/b/c/d/e/f/");
+ common = pathFactory.create("/a/b/c");
+ assertThat(path1.getCommonAncestor(path2), is(common));
+ }
- @Test
- public void shouldConsiderRootTheLowestCommonAncestorOfAnyNodesOnSeparateBrances() {
- Path path1 = pathFactory.create("/x/y/z");
- Path path2 = pathFactory.create("/a/b/c");
- Path common = ROOT;
- assertThat(path1.getCommonAncestor(path2), is(common));
- }
+ @Test
+ public void shouldConsiderRootTheLowestCommonAncestorOfAnyNodesOnSeparateBrances() {
+ Path path1 = pathFactory.create("/x/y/z");
+ Path path2 = pathFactory.create("/a/b/c");
+ Path common = ROOT;
+ assertThat(path1.getCommonAncestor(path2), is(common));
+ }
- @Test
- public void shouldConsiderNodeToBeAncestorOfEveryDecendantNode() {
- Path path1 = pathFactory.create("/a/y/z");
- Path path2 = pathFactory.create("/a/b/c");
- Path path3 = pathFactory.create("/x/b/c");
- Path path4 = pathFactory.create("/a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q/r/s/t/u/v/w/x/y/z");
- Path common = pathFactory.create("/a");
- assertThat(common.isAncestorOf(path1), is(true));
- assertThat(common.isAncestorOf(path2), is(true));
- assertThat(common.isAncestorOf(path3), is(false));
+ @Test
+ public void shouldConsiderNodeToBeAncestorOfEveryDecendantNode() {
+ Path path1 = pathFactory.create("/a/y/z");
+ Path path2 = pathFactory.create("/a/b/c");
+ Path path3 = pathFactory.create("/x/b/c");
+ Path path4 = pathFactory.create("/a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q/r/s/t/u/v/w/x/y/z");
+ Path common = pathFactory.create("/a");
+ assertThat(common.isAncestorOf(path1), is(true));
+ assertThat(common.isAncestorOf(path2), is(true));
+ assertThat(common.isAncestorOf(path3), is(false));
- assertThat(path1.getAncestor().isAncestorOf(path1), is(true));
- for (int i = 1; i < path1.size(); ++i) {
- assertThat(path1.getAncestor(i).isAncestorOf(path1), is(true));
- }
- for (int i = 1; i < path2.size(); ++i) {
- assertThat(path2.getAncestor(i).isAncestorOf(path2), is(true));
- }
- for (int i = 1; i < path3.size(); ++i) {
- assertThat(path3.getAncestor(i).isAncestorOf(path3), is(true));
- }
- for (int i = 1; i < path4.size(); ++i) {
- assertThat(path4.getAncestor(i).isAncestorOf(path4), is(true));
- }
- }
+ assertThat(path1.getAncestor().isAncestorOf(path1), is(true));
+ for (int i = 1; i < path1.size(); ++i) {
+ assertThat(path1.getAncestor(i).isAncestorOf(path1), is(true));
+ }
+ for (int i = 1; i < path2.size(); ++i) {
+ assertThat(path2.getAncestor(i).isAncestorOf(path2), is(true));
+ }
+ for (int i = 1; i < path3.size(); ++i) {
+ assertThat(path3.getAncestor(i).isAncestorOf(path3), is(true));
+ }
+ for (int i = 1; i < path4.size(); ++i) {
+ assertThat(path4.getAncestor(i).isAncestorOf(path4), is(true));
+ }
+ }
- @Test
- public void shouldConsiderNodeToBeDecendantOfEveryAncestorNode() {
- Path path1 = pathFactory.create("/a/y/z");
- Path path2 = pathFactory.create("/a/b/c");
- Path path3 = pathFactory.create("/x/b/c");
- Path path4 = pathFactory.create("/a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q/r/s/t/u/v/w/x/y/z");
- Path common = pathFactory.create("/a");
- assertThat(path1.isDecendantOf(common), is(true));
- assertThat(path2.isDecendantOf(common), is(true));
- assertThat(path3.isDecendantOf(common), is(false));
+ @Test
+ public void shouldConsiderNodeToBeDecendantOfEveryAncestorNode() {
+ Path path1 = pathFactory.create("/a/y/z");
+ Path path2 = pathFactory.create("/a/b/c");
+ Path path3 = pathFactory.create("/x/b/c");
+ Path path4 = pathFactory.create("/a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q/r/s/t/u/v/w/x/y/z");
+ Path common = pathFactory.create("/a");
+ assertThat(path1.isDecendantOf(common), is(true));
+ assertThat(path2.isDecendantOf(common), is(true));
+ assertThat(path3.isDecendantOf(common), is(false));
- assertThat(path1.getAncestor().isAncestorOf(path1), is(true));
- for (int i = 1; i < path1.size(); ++i) {
- assertThat(path1.isDecendantOf(path1.getAncestor(i)), is(true));
- }
- for (int i = 1; i < path2.size(); ++i) {
- assertThat(path2.isDecendantOf(path2.getAncestor(i)), is(true));
- }
- for (int i = 1; i < path3.size(); ++i) {
- assertThat(path3.isDecendantOf(path3.getAncestor(i)), is(true));
- }
- for (int i = 1; i < path4.size(); ++i) {
- assertThat(path4.isDecendantOf(path4.getAncestor(i)), is(true));
- }
- }
+ assertThat(path1.getAncestor().isAncestorOf(path1), is(true));
+ for (int i = 1; i < path1.size(); ++i) {
+ assertThat(path1.isDecendantOf(path1.getAncestor(i)), is(true));
+ }
+ for (int i = 1; i < path2.size(); ++i) {
+ assertThat(path2.isDecendantOf(path2.getAncestor(i)), is(true));
+ }
+ for (int i = 1; i < path3.size(); ++i) {
+ assertThat(path3.isDecendantOf(path3.getAncestor(i)), is(true));
+ }
+ for (int i = 1; i < path4.size(); ++i) {
+ assertThat(path4.isDecendantOf(path4.getAncestor(i)), is(true));
+ }
+ }
- @Test
- public void shouldNotConsiderNodeToBeAncestorOfItself() {
- Path path1 = pathFactory.create("/a/y/z");
- Path path2 = pathFactory.create("/a/b/c");
- Path path3 = pathFactory.create("/x/b/c");
- assertThat(path1.isAncestorOf(path1), is(false));
- assertThat(path2.isAncestorOf(path2), is(false));
- assertThat(path3.isAncestorOf(path3), is(false));
- assertThat(ROOT.isAncestorOf(ROOT), is(false));
- }
+ @Test
+ public void shouldNotConsiderNodeToBeAncestorOfItself() {
+ Path path1 = pathFactory.create("/a/y/z");
+ Path path2 = pathFactory.create("/a/b/c");
+ Path path3 = pathFactory.create("/x/b/c");
+ assertThat(path1.isAncestorOf(path1), is(false));
+ assertThat(path2.isAncestorOf(path2), is(false));
+ assertThat(path3.isAncestorOf(path3), is(false));
+ assertThat(ROOT.isAncestorOf(ROOT), is(false));
+ }
- @Test
- public void shouldNotConsiderNodeToBeDecendantOfItself() {
- Path path1 = pathFactory.create("/a/y/z");
- Path path2 = pathFactory.create("/a/b/c");
- Path path3 = pathFactory.create("/x/b/c");
- assertThat(path1.isDecendantOf(path1), is(false));
- assertThat(path2.isDecendantOf(path2), is(false));
- assertThat(path3.isDecendantOf(path3), is(false));
- assertThat(ROOT.isDecendantOf(ROOT), is(false));
- }
+ @Test
+ public void shouldNotConsiderNodeToBeDecendantOfItself() {
+ Path path1 = pathFactory.create("/a/y/z");
+ Path path2 = pathFactory.create("/a/b/c");
+ Path path3 = pathFactory.create("/x/b/c");
+ assertThat(path1.isDecendantOf(path1), is(false));
+ assertThat(path2.isDecendantOf(path2), is(false));
+ assertThat(path3.isDecendantOf(path3), is(false));
+ assertThat(ROOT.isDecendantOf(ROOT), is(false));
+ }
- @Test
- public void shouldNotConsiderRootToBeDecendantOfAnyNode() {
- Path path1 = pathFactory.create("/a/y/z");
- Path path2 = pathFactory.create("/a/b/c");
- Path path3 = pathFactory.create("/x/b/c");
- Path common = pathFactory.create("/a");
- assertThat(ROOT.isDecendantOf(path1), is(false));
- assertThat(ROOT.isDecendantOf(path2), is(false));
- assertThat(ROOT.isDecendantOf(path3), is(false));
- assertThat(ROOT.isDecendantOf(common), is(false));
- }
+ @Test
+ public void shouldNotConsiderRootToBeDecendantOfAnyNode() {
+ Path path1 = pathFactory.create("/a/y/z");
+ Path path2 = pathFactory.create("/a/b/c");
+ Path path3 = pathFactory.create("/x/b/c");
+ Path common = pathFactory.create("/a");
+ assertThat(ROOT.isDecendantOf(path1), is(false));
+ assertThat(ROOT.isDecendantOf(path2), is(false));
+ assertThat(ROOT.isDecendantOf(path3), is(false));
+ assertThat(ROOT.isDecendantOf(common), is(false));
+ }
- @Test
- public void shouldConsiderRootToBeAncestorOfAnyNode() {
- Path path1 = pathFactory.create("/a/y/z");
- Path path2 = pathFactory.create("/a/b/c");
- Path path3 = pathFactory.create("/x/b/c");
- Path common = pathFactory.create("/a");
- assertThat(ROOT.isAncestorOf(path1), is(true));
- assertThat(ROOT.isAncestorOf(path2), is(true));
- assertThat(ROOT.isAncestorOf(path3), is(true));
- assertThat(ROOT.isAncestorOf(common), is(true));
- }
+ @Test
+ public void shouldConsiderRootToBeAncestorOfAnyNode() {
+ Path path1 = pathFactory.create("/a/y/z");
+ Path path2 = pathFactory.create("/a/b/c");
+ Path path3 = pathFactory.create("/x/b/c");
+ Path common = pathFactory.create("/a");
+ assertThat(ROOT.isAncestorOf(path1), is(true));
+ assertThat(ROOT.isAncestorOf(path2), is(true));
+ assertThat(ROOT.isAncestorOf(path3), is(true));
+ assertThat(ROOT.isAncestorOf(common), is(true));
+ }
- @Test
- public void shouldNotConsiderRootToBeAncestorOfItself() {
- assertThat(ROOT.isAncestorOf(ROOT), is(false));
- }
+ @Test
+ public void shouldNotConsiderRootToBeAncestorOfItself() {
+ assertThat(ROOT.isAncestorOf(ROOT), is(false));
+ }
- @Test
- public void shouldNotConsiderRootToBeDecendantOfItself() {
- assertThat(ROOT.isDecendantOf(ROOT), is(false));
- }
+ @Test
+ public void shouldNotConsiderRootToBeDecendantOfItself() {
+ assertThat(ROOT.isDecendantOf(ROOT), is(false));
+ }
- @Test
- public void shouldNeverBeDecendantOfNullPath() {
- assertThat(path.isDecendantOf(null), is(false));
- assertThat(ROOT.isDecendantOf(null), is(false));
- }
+ @Test
+ public void shouldNeverBeDecendantOfNullPath() {
+ assertThat(path.isDecendantOf(null), is(false));
+ assertThat(ROOT.isDecendantOf(null), is(false));
+ }
- @Test
- public void shouldReturnNullForLastSegmentOfRoot() {
- assertThat(ROOT.getLastSegment(), is(nullValue()));
- }
+ @Test
+ public void shouldReturnNullForLastSegmentOfRoot() {
+ assertThat(ROOT.getLastSegment(), is(nullValue()));
+ }
- @Test
- public void shouldReturnLastSegmentOfNonRootPath() {
- Path path1 = pathFactory.create("/a/y/z");
- Path path2 = pathFactory.create("/a/b/c");
- Path path3 = pathFactory.create("/x/b/c");
- Path path4 = pathFactory.create("/a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q/r/s/t/u/v/w/x");
- assertThat(path1.getLastSegment().getName().getLocalName(), is("z"));
- assertThat(path2.getLastSegment().getName().getLocalName(), is("c"));
- assertThat(path3.getLastSegment().getName().getLocalName(), is("c"));
- assertThat(path4.getLastSegment().getName().getLocalName(), is("x"));
- }
+ @Test
+ public void shouldReturnLastSegmentOfNonRootPath() {
+ Path path1 = pathFactory.create("/a/y/z");
+ Path path2 = pathFactory.create("/a/b/c");
+ Path path3 = pathFactory.create("/x/b/c");
+ Path path4 = pathFactory.create("/a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q/r/s/t/u/v/w/x");
+ assertThat(path1.getLastSegment().getName().getLocalName(), is("z"));
+ assertThat(path2.getLastSegment().getName().getLocalName(), is("c"));
+ assertThat(path3.getLastSegment().getName().getLocalName(), is("c"));
+ assertThat(path4.getLastSegment().getName().getLocalName(), is("x"));
+ }
- @Test
- public void shouldNormalizePathWithSelfAndParentReferences() {
- path = pathFactory.create("/a/b/c/../d/./e/../..");
- assertThat(path.isNormalized(), is(false));
- assertThat(path.getNormalizedPath(), hasSegments(pathFactory, "a", "b"));
- assertThat(path.getNormalizedPath().isAbsolute(), is(true));
- assertThat(path.getNormalizedPath().isNormalized(), is(true));
+ @Test
+ public void shouldNormalizePathWithSelfAndParentReferences() {
+ path = pathFactory.create("/a/b/c/../d/./e/../..");
+ assertThat(path.isNormalized(), is(false));
+ assertThat(path.getNormalizedPath(), hasSegments(pathFactory, "a", "b"));
+ assertThat(path.getNormalizedPath().isAbsolute(), is(true));
+ assertThat(path.getNormalizedPath().isNormalized(), is(true));
- path = pathFactory.create("a/b/c/../d/./e/../..");
- assertThat(path.isNormalized(), is(false));
- assertThat(path.getNormalizedPath(), hasSegments(pathFactory, "a", "b"));
- assertThat(path.getNormalizedPath().isAbsolute(), is(false));
- assertThat(path.getNormalizedPath().isNormalized(), is(true));
- }
+ path = pathFactory.create("a/b/c/../d/./e/../..");
+ assertThat(path.isNormalized(), is(false));
+ assertThat(path.getNormalizedPath(), hasSegments(pathFactory, "a", "b"));
+ assertThat(path.getNormalizedPath().isAbsolute(), is(false));
+ assertThat(path.getNormalizedPath().isNormalized(), is(true));
+ }
- @Test
- public void shouldAlreadyBeNormalizedIfPathContainsNoParentOrSelfReferences() {
- assertThat(pathFactory.create("/a/b/c/d/e").isNormalized(), is(true));
- assertThat(pathFactory.create("a/b/c/d/e").isNormalized(), is(true));
- assertThat(pathFactory.create("a").isNormalized(), is(true));
- assertThat(pathFactory.create("/a").isNormalized(), is(true));
- assertThat(ROOT.isNormalized(), is(true));
- }
+ @Test
+ public void shouldAlreadyBeNormalizedIfPathContainsNoParentOrSelfReferences() {
+ assertThat(pathFactory.create("/a/b/c/d/e").isNormalized(), is(true));
+ assertThat(pathFactory.create("a/b/c/d/e").isNormalized(), is(true));
+ assertThat(pathFactory.create("a").isNormalized(), is(true));
+ assertThat(pathFactory.create("/a").isNormalized(), is(true));
+ assertThat(ROOT.isNormalized(), is(true));
+ }
- @Test
- public void shouldNotBeNormalizedIfPathContainsParentOrSelfReferences() {
- assertThat(pathFactory.create("/a/b/c/../d/./e/../..").isNormalized(), is(false));
- assertThat(pathFactory.create("a/b/c/../d/./e/../..").isNormalized(), is(false));
- assertThat(pathFactory.create("a/b/c/./d").isNormalized(), is(false));
- assertThat(pathFactory.create("/a/b/c/../d").isNormalized(), is(false));
- assertThat(pathFactory.create(".").isNormalized(), is(false));
- assertThat(pathFactory.create("/.").isNormalized(), is(false));
- }
+ @Test
+ public void shouldNotBeNormalizedIfPathContainsParentOrSelfReferences() {
+ assertThat(pathFactory.create("/a/b/c/../d/./e/../..").isNormalized(), is(false));
+ assertThat(pathFactory.create("a/b/c/../d/./e/../..").isNormalized(), is(false));
+ assertThat(pathFactory.create("a/b/c/./d").isNormalized(), is(false));
+ assertThat(pathFactory.create("/a/b/c/../d").isNormalized(), is(false));
+ assertThat(pathFactory.create(".").isNormalized(), is(false));
+ assertThat(pathFactory.create("/.").isNormalized(), is(false));
+ }
- @Test( expected = InvalidPathException.class )
- public void shouldFailToReturnNormalizedPathIfPathContainsReferencesToParentsAboveRoot() {
- path = pathFactory.create("/a/../../../..");
- assertThat(path.isNormalized(), is(false));
- path.getNormalizedPath();
- }
+ @Test( expected = InvalidPathException.class )
+ public void shouldFailToReturnNormalizedPathIfPathContainsReferencesToParentsAboveRoot() {
+ path = pathFactory.create("/a/../../../..");
+ assertThat(path.isNormalized(), is(false));
+ path.getNormalizedPath();
+ }
- @Test
- public void shouldReturnRootPathAsTheNormalizedPathForAnAbsolutePathWithZeroSegmentsAfterParentAndSelfReferencesRemoved() {
- // "/a/../b/../c/.." => "/"
- path = pathFactory.create("/a/../b/../c/../");
- assertThat(path.isNormalized(), is(false));
- assertThat(path.getNormalizedPath(), is(ROOT));
- }
+ @Test
+ public void shouldReturnRootPathAsTheNormalizedPathForAnAbsolutePathWithZeroSegmentsAfterParentAndSelfReferencesRemoved() {
+ // "/a/../b/../c/.." => "/"
+ path = pathFactory.create("/a/../b/../c/../");
+ assertThat(path.isNormalized(), is(false));
+ assertThat(path.getNormalizedPath(), is(ROOT));
+ }
- @Test
- public void shouldReturnSelfPathAsTheNormalizedPathForARelativePathWithZeroSegmentsAfterParentAndSelfReferencesRemoved() {
- // "a/../b/../c/.." => "."
- path = pathFactory.create("a/../b/../c/../");
- assertThat(path.isNormalized(), is(false));
- assertThat(path.getNormalizedPath().size(), is(1));
- assertThat(path.getNormalizedPath(), hasSegments(pathFactory, "."));
- }
+ @Test
+ public void shouldReturnSelfPathAsTheNormalizedPathForARelativePathWithZeroSegmentsAfterParentAndSelfReferencesRemoved() {
+ // "a/../b/../c/.." => "."
+ path = pathFactory.create("a/../b/../c/../");
+ assertThat(path.isNormalized(), is(false));
+ assertThat(path.getNormalizedPath().size(), is(1));
+ assertThat(path.getNormalizedPath(), hasSegments(pathFactory, "."));
+ }
- @Test
- public void shouldNotHaveAnyParentOrSelfReferencesInTheNormalizedPathOfAnAbsolutePath() {
- path = pathFactory.create("/a/b/c/../d/./e/../..");
- assertThat(path.isNormalized(), is(false));
- assertThat(path.getNormalizedPath(), hasSegments(pathFactory, "a", "b"));
- assertThat(path.getNormalizedPath().isAbsolute(), is(true));
- assertThat(path.getNormalizedPath().isNormalized(), is(true));
- }
+ @Test
+ public void shouldNotHaveAnyParentOrSelfReferencesInTheNormalizedPathOfAnAbsolutePath() {
+ path = pathFactory.create("/a/b/c/../d/./e/../..");
+ assertThat(path.isNormalized(), is(false));
+ assertThat(path.getNormalizedPath(), hasSegments(pathFactory, "a", "b"));
+ assertThat(path.getNormalizedPath().isAbsolute(), is(true));
+ assertThat(path.getNormalizedPath().isNormalized(), is(true));
+ }
- @Test
- public void shouldNotHaveAnyParentReferencesInTheNormalizedPathOfARelativePath() {
- path = pathFactory.create("a/b/c/../d/./e/../..");
- assertThat(path.isNormalized(), is(false));
- assertThat(path.getNormalizedPath(), hasSegments(pathFactory, "a", "b"));
- assertThat(path.getNormalizedPath().isAbsolute(), is(false));
- assertThat(path.getNormalizedPath().isNormalized(), is(true));
- }
+ @Test
+ public void shouldNotHaveAnyParentReferencesInTheNormalizedPathOfARelativePath() {
+ path = pathFactory.create("a/b/c/../d/./e/../..");
+ assertThat(path.isNormalized(), is(false));
+ assertThat(path.getNormalizedPath(), hasSegments(pathFactory, "a", "b"));
+ assertThat(path.getNormalizedPath().isAbsolute(), is(false));
+ assertThat(path.getNormalizedPath().isNormalized(), is(true));
+ }
- @Test( expected = InvalidPathException.class )
- public void shouldNotComputeCanonicalPathOfNodeThatIsNotAbsolute() {
- pathFactory.create("a/b/c/../d/./e/../..").getCanonicalPath();
- }
+ @Test( expected = InvalidPathException.class )
+ public void shouldNotComputeCanonicalPathOfNodeThatIsNotAbsolute() {
+ pathFactory.create("a/b/c/../d/./e/../..").getCanonicalPath();
+ }
- @Test
- public void shouldReturnNormalizedPathForTheCanonicalPathOfAbsolutePath() {
- path = pathFactory.create("/a/b/c/../d/./e/../..");
- assertThat(path.isNormalized(), is(false));
- assertThat(path.isAbsolute(), is(true));
- assertThat(path.getCanonicalPath(), hasSegments(pathFactory, "a", "b"));
- assertThat(path.getCanonicalPath().isAbsolute(), is(true));
- assertThat(path.getCanonicalPath().isNormalized(), is(true));
- }
+ @Test
+ public void shouldReturnNormalizedPathForTheCanonicalPathOfAbsolutePath() {
+ path = pathFactory.create("/a/b/c/../d/./e/../..");
+ assertThat(path.isNormalized(), is(false));
+ assertThat(path.isAbsolute(), is(true));
+ assertThat(path.getCanonicalPath(), hasSegments(pathFactory, "a", "b"));
+ assertThat(path.getCanonicalPath().isAbsolute(), is(true));
+ assertThat(path.getCanonicalPath().isNormalized(), is(true));
+ }
- @Test
- public void shouldReturnSameSegmentsInIteratorAndArrayAndList() {
- testSegmentsByIteratorAndListAndArray("/a/b/c/../d/./e/../..", "a", "b", "c", "..", "d", ".", "e", "..", "..");
- testSegmentsByIteratorAndListAndArray("/a/b/c", "a", "b", "c");
- testSegmentsByIteratorAndListAndArray("a/b/c/../d/./e/../..", "a", "b", "c", "..", "d", ".", "e", "..", "..");
- testSegmentsByIteratorAndListAndArray("a/b/c", "a", "b", "c");
- testSegmentsByIteratorAndListAndArray("");
- testSegmentsByIteratorAndListAndArray(ROOT.getString());
- }
+ @Test
+ public void shouldReturnSameSegmentsInIteratorAndArrayAndList() {
+ testSegmentsByIteratorAndListAndArray("/a/b/c/../d/./e/../..", "a", "b", "c", "..", "d", ".", "e", "..", "..");
+ testSegmentsByIteratorAndListAndArray("/a/b/c", "a", "b", "c");
+ testSegmentsByIteratorAndListAndArray("a/b/c/../d/./e/../..", "a", "b", "c", "..", "d", ".", "e", "..", "..");
+ testSegmentsByIteratorAndListAndArray("a/b/c", "a", "b", "c");
+ testSegmentsByIteratorAndListAndArray("");
+ testSegmentsByIteratorAndListAndArray(ROOT.getString());
+ }
- public void testSegmentsByIteratorAndListAndArray( String pathStr,
- String... expectedSegmentStrings ) {
- path = pathFactory.create(pathStr);
- assertThat(expectedSegmentStrings.length, is(path.size()));
- Path.Segment[] segmentArray = path.getSegmentsArray();
- List<Path.Segment> segmentList = path.getSegmentsList();
- assertThat(segmentArray.length, is(path.size()));
- assertThat(segmentList.size(), is(path.size()));
- Iterator<Path.Segment> iter = path.iterator();
- Iterator<Path.Segment> listIter = segmentList.iterator();
- for (int i = 0; i != path.size(); ++i) {
- Path.Segment expected = pathFactory.createSegment(expectedSegmentStrings[i]);
- assertThat(path.getSegment(i), is(expected));
- assertThat(segmentArray[i], is(expected));
- assertThat(segmentList.get(i), is(expected));
- assertThat(iter.next(), is(expected));
- assertThat(listIter.next(), is(expected));
- }
- assertThat(iter.hasNext(), is(false));
- assertThat(listIter.hasNext(), is(false));
- }
+ public void testSegmentsByIteratorAndListAndArray( String pathStr, String... expectedSegmentStrings ) {
+ path = pathFactory.create(pathStr);
+ assertThat(expectedSegmentStrings.length, is(path.size()));
+ Path.Segment[] segmentArray = path.getSegmentsArray();
+ List<Path.Segment> segmentList = path.getSegmentsList();
+ assertThat(segmentArray.length, is(path.size()));
+ assertThat(segmentList.size(), is(path.size()));
+ Iterator<Path.Segment> iter = path.iterator();
+ Iterator<Path.Segment> listIter = segmentList.iterator();
+ for (int i = 0; i != path.size(); ++i) {
+ Path.Segment expected = pathFactory.createSegment(expectedSegmentStrings[i]);
+ assertThat(path.getSegment(i), is(expected));
+ assertThat(segmentArray[i], is(expected));
+ assertThat(segmentList.get(i), is(expected));
+ assertThat(iter.next(), is(expected));
+ assertThat(listIter.next(), is(expected));
+ }
+ assertThat(iter.hasNext(), is(false));
+ assertThat(listIter.hasNext(), is(false));
+ }
- @Test
- public void shouldGetStringWithNamespaceUrisIfNoNamespaceRegistryIsProvided() {
- path = pathFactory.create("/dna:a/b/dna:c/../d/./dna:e/../..");
- assertThat(path.getString(NO_OP_ENCODER),
- is("/{http://www.jboss.org/dna}a/{}b/{http://www.jboss.org/dna}c/../{}d/./{http://www.jboss.org/dna}e/../.."));
- }
+ @Test
+ public void shouldGetStringWithNamespaceUrisIfNoNamespaceRegistryIsProvided() {
+ path = pathFactory.create("/dna:a/b/dna:c/../d/./dna:e/../..");
+ assertThat(path.getString(NO_OP_ENCODER), is("/{http://www.jboss.org/dna}a/{}b/{http://www.jboss.org/dna}c/../{}d/./{http://www.jboss.org/dna}e/../.."));
+ }
- @Test
- public void shouldGetStringWithNamespacePrefixesForAllNamesIfNamespaceRegistryIsProvided() {
- path = pathFactory.create("/dna:a/b/dna:c/../d/./dna:e/../..");
- assertThat(path.getString(namespaceRegistry, NO_OP_ENCODER), is("/dna:a/b/dna:c/../d/./dna:e/../.."));
- namespaceRegistry.register("dna2", validNamespaceUri);
- assertThat(path.getString(namespaceRegistry, NO_OP_ENCODER), is("/dna2:a/b/dna2:c/../d/./dna2:e/../.."));
- }
+ @Test
+ public void shouldGetStringWithNamespacePrefixesForAllNamesIfNamespaceRegistryIsProvided() {
+ path = pathFactory.create("/dna:a/b/dna:c/../d/./dna:e/../..");
+ assertThat(path.getString(namespaceRegistry, NO_OP_ENCODER), is("/dna:a/b/dna:c/../d/./dna:e/../.."));
+ namespaceRegistry.register("dna2", validNamespaceUri);
+ assertThat(path.getString(namespaceRegistry, NO_OP_ENCODER), is("/dna2:a/b/dna2:c/../d/./dna2:e/../.."));
+ }
- @Test( expected = IndexOutOfBoundsException.class )
- public void shouldFailToReturnSubpathIfStartingIndexIsNegative() {
- path = pathFactory.create("/dna:a/b/dna:c/../d/./dna:e/../..");
- path.subpath(-1);
- }
+ @Test( expected = IndexOutOfBoundsException.class )
+ public void shouldFailToReturnSubpathIfStartingIndexIsNegative() {
+ path = pathFactory.create("/dna:a/b/dna:c/../d/./dna:e/../..");
+ path.subpath(-1);
+ }
- @Test( expected = IndexOutOfBoundsException.class )
- public void shouldFailToReturnSubpathWithoutEndingIndexIfStartingIndexIsEqualToOrLargerThanSize() {
- path = pathFactory.create("/dna:a/b/dna:c/../d/./dna:e/../..");
- path.subpath(path.size() + 1);
- }
+ @Test( expected = IndexOutOfBoundsException.class )
+ public void shouldFailToReturnSubpathWithoutEndingIndexIfStartingIndexIsEqualToOrLargerThanSize() {
+ path = pathFactory.create("/dna:a/b/dna:c/../d/./dna:e/../..");
+ path.subpath(path.size() + 1);
+ }
- @Test( expected = IndexOutOfBoundsException.class )
- public void shouldFailToReturnSubpathWithEndingIndexIfStartingIndexIsEqualToOrLargerThanSize() {
- path = pathFactory.create("/dna:a/b/dna:c/../d/./dna:e/../..");
- path.subpath(path.size() + 1, path.size() + 2);
- }
+ @Test( expected = IndexOutOfBoundsException.class )
+ public void shouldFailToReturnSubpathWithEndingIndexIfStartingIndexIsEqualToOrLargerThanSize() {
+ path = pathFactory.create("/dna:a/b/dna:c/../d/./dna:e/../..");
+ path.subpath(path.size() + 1, path.size() + 2);
+ }
- @Test( expected = IndexOutOfBoundsException.class )
- public void shouldFailToReturnSubpathIfEndingIndexIsSmallerThanStartingIndex() {
- path = pathFactory.create("/dna:a/b/dna:c/../d/./dna:e/../..");
- path.subpath(2, 1);
- }
+ @Test( expected = IndexOutOfBoundsException.class )
+ public void shouldFailToReturnSubpathIfEndingIndexIsSmallerThanStartingIndex() {
+ path = pathFactory.create("/dna:a/b/dna:c/../d/./dna:e/../..");
+ path.subpath(2, 1);
+ }
- @Test( expected = IndexOutOfBoundsException.class )
- public void shouldFailToReturnSubpathIfEndingIndexIsEqualToOrLargerThanSize() {
- path = pathFactory.create("/dna:a/b/dna:c/../d/./dna:e/../..");
- path.subpath(2, path.size() + 1);
- }
+ @Test( expected = IndexOutOfBoundsException.class )
+ public void shouldFailToReturnSubpathIfEndingIndexIsEqualToOrLargerThanSize() {
+ path = pathFactory.create("/dna:a/b/dna:c/../d/./dna:e/../..");
+ path.subpath(2, path.size() + 1);
+ }
- @Test
- public void shouldReturnRootAsSubpathIfStartingIndexAndEndingIndexAreBothZero() {
- path = pathFactory.create("/dna:a/b/dna:c/../d/./dna:e/../..");
- assertThat(path.subpath(0, 0), is(ROOT));
- }
+ @Test
+ public void shouldReturnRootAsSubpathIfStartingIndexAndEndingIndexAreBothZero() {
+ path = pathFactory.create("/dna:a/b/dna:c/../d/./dna:e/../..");
+ assertThat(path.subpath(0, 0), is(ROOT));
+ }
- @Test
- public void shouldReturnSubpathIfValidStartingIndexAndNoEndingIndexAreProvided() {
- path = pathFactory.create("/dna:a/b/dna:c/../d/./dna:e/../..");
- assertThat(path.subpath(0), hasSegments(pathFactory, "dna:a", "b", "dna:c", "..", "d", ".", "dna:e", "..", ".."));
- assertThat(path.subpath(0), is(path));
- assertThat(path.subpath(0), is(sameInstance(path)));
- assertThat(path.subpath(1), hasSegments(pathFactory, "b", "dna:c", "..", "d", ".", "dna:e", "..", ".."));
- assertThat(path.subpath(2), hasSegments(pathFactory, "dna:c", "..", "d", ".", "dna:e", "..", ".."));
- assertThat(path.subpath(3), hasSegments(pathFactory, "..", "d", ".", "dna:e", "..", ".."));
- assertThat(path.subpath(4), hasSegments(pathFactory, "d", ".", "dna:e", "..", ".."));
- assertThat(path.subpath(5), hasSegments(pathFactory, ".", "dna:e", "..", ".."));
- assertThat(path.subpath(6), hasSegments(pathFactory, "dna:e", "..", ".."));
- assertThat(path.subpath(7), hasSegments(pathFactory, "..", ".."));
- assertThat(path.subpath(8), hasSegments(pathFactory, ".."));
+ @Test
+ public void shouldReturnSubpathIfValidStartingIndexAndNoEndingIndexAreProvided() {
+ path = pathFactory.create("/dna:a/b/dna:c/../d/./dna:e/../..");
+ assertThat(path.subpath(0), hasSegments(pathFactory, "dna:a", "b", "dna:c", "..", "d", ".", "dna:e", "..", ".."));
+ assertThat(path.subpath(0), is(path));
+ assertThat(path.subpath(0), is(sameInstance(path)));
+ assertThat(path.subpath(1), hasSegments(pathFactory, "b", "dna:c", "..", "d", ".", "dna:e", "..", ".."));
+ assertThat(path.subpath(2), hasSegments(pathFactory, "dna:c", "..", "d", ".", "dna:e", "..", ".."));
+ assertThat(path.subpath(3), hasSegments(pathFactory, "..", "d", ".", "dna:e", "..", ".."));
+ assertThat(path.subpath(4), hasSegments(pathFactory, "d", ".", "dna:e", "..", ".."));
+ assertThat(path.subpath(5), hasSegments(pathFactory, ".", "dna:e", "..", ".."));
+ assertThat(path.subpath(6), hasSegments(pathFactory, "dna:e", "..", ".."));
+ assertThat(path.subpath(7), hasSegments(pathFactory, "..", ".."));
+ assertThat(path.subpath(8), hasSegments(pathFactory, ".."));
- path = pathFactory.create("dna:a/b/dna:c/../d/./dna:e/../..");
- assertThat(path.subpath(0), hasSegments(pathFactory, "dna:a", "b", "dna:c", "..", "d", ".", "dna:e", "..", ".."));
- assertThat(path.subpath(0), is(path));
- assertThat(path.subpath(0), is(sameInstance(path)));
- assertThat(path.subpath(1), hasSegments(pathFactory, "b", "dna:c", "..", "d", ".", "dna:e", "..", ".."));
- assertThat(path.subpath(2), hasSegments(pathFactory, "dna:c", "..", "d", ".", "dna:e", "..", ".."));
- assertThat(path.subpath(3), hasSegments(pathFactory, "..", "d", ".", "dna:e", "..", ".."));
- assertThat(path.subpath(4), hasSegments(pathFactory, "d", ".", "dna:e", "..", ".."));
- assertThat(path.subpath(5), hasSegments(pathFactory, ".", "dna:e", "..", ".."));
- assertThat(path.subpath(6), hasSegments(pathFactory, "dna:e", "..", ".."));
- assertThat(path.subpath(7), hasSegments(pathFactory, "..", ".."));
- assertThat(path.subpath(8), hasSegments(pathFactory, ".."));
- }
+ path = pathFactory.create("dna:a/b/dna:c/../d/./dna:e/../..");
+ assertThat(path.subpath(0), hasSegments(pathFactory, "dna:a", "b", "dna:c", "..", "d", ".", "dna:e", "..", ".."));
+ assertThat(path.subpath(0), is(path));
+ assertThat(path.subpath(0), is(sameInstance(path)));
+ assertThat(path.subpath(1), hasSegments(pathFactory, "b", "dna:c", "..", "d", ".", "dna:e", "..", ".."));
+ assertThat(path.subpath(2), hasSegments(pathFactory, "dna:c", "..", "d", ".", "dna:e", "..", ".."));
+ assertThat(path.subpath(3), hasSegments(pathFactory, "..", "d", ".", "dna:e", "..", ".."));
+ assertThat(path.subpath(4), hasSegments(pathFactory, "d", ".", "dna:e", "..", ".."));
+ assertThat(path.subpath(5), hasSegments(pathFactory, ".", "dna:e", "..", ".."));
+ assertThat(path.subpath(6), hasSegments(pathFactory, "dna:e", "..", ".."));
+ assertThat(path.subpath(7), hasSegments(pathFactory, "..", ".."));
+ assertThat(path.subpath(8), hasSegments(pathFactory, ".."));
+ }
- @Test
- public void shouldReturnSubpathIfValidStartingIndexAndEndingIndexAreProvided() {
- path = pathFactory.create("/dna:a/b/dna:c/../d/./dna:e/../..");
- assertThat(path.subpath(0, path.size()), hasSegments(pathFactory,
- "dna:a",
- "b",
- "dna:c",
- "..",
- "d",
- ".",
- "dna:e",
- "..",
- ".."));
- assertThat(path.subpath(0, path.size()), is(path));
- assertThat(path.subpath(0, path.size()), is(sameInstance(path)));
- assertThat(path.subpath(1, path.size()), hasSegments(pathFactory, "b", "dna:c", "..", "d", ".", "dna:e", "..", ".."));
- assertThat(path.subpath(2, path.size()), hasSegments(pathFactory, "dna:c", "..", "d", ".", "dna:e", "..", ".."));
- assertThat(path.subpath(3, path.size()), hasSegments(pathFactory, "..", "d", ".", "dna:e", "..", ".."));
- assertThat(path.subpath(4, path.size()), hasSegments(pathFactory, "d", ".", "dna:e", "..", ".."));
- assertThat(path.subpath(5, path.size()), hasSegments(pathFactory, ".", "dna:e", "..", ".."));
- assertThat(path.subpath(6, path.size()), hasSegments(pathFactory, "dna:e", "..", ".."));
- assertThat(path.subpath(7, path.size()), hasSegments(pathFactory, "..", ".."));
- assertThat(path.subpath(8, path.size()), hasSegments(pathFactory, ".."));
+ @Test
+ public void shouldReturnSubpathIfValidStartingIndexAndEndingIndexAreProvided() {
+ path = pathFactory.create("/dna:a/b/dna:c/../d/./dna:e/../..");
+ assertThat(path.subpath(0, path.size()), hasSegments(pathFactory, "dna:a", "b", "dna:c", "..", "d", ".", "dna:e", "..", ".."));
+ assertThat(path.subpath(0, path.size()), is(path));
+ assertThat(path.subpath(0, path.size()), is(sameInstance(path)));
+ assertThat(path.subpath(1, path.size()), hasSegments(pathFactory, "b", "dna:c", "..", "d", ".", "dna:e", "..", ".."));
+ assertThat(path.subpath(2, path.size()), hasSegments(pathFactory, "dna:c", "..", "d", ".", "dna:e", "..", ".."));
+ assertThat(path.subpath(3, path.size()), hasSegments(pathFactory, "..", "d", ".", "dna:e", "..", ".."));
+ assertThat(path.subpath(4, path.size()), hasSegments(pathFactory, "d", ".", "dna:e", "..", ".."));
+ assertThat(path.subpath(5, path.size()), hasSegments(pathFactory, ".", "dna:e", "..", ".."));
+ assertThat(path.subpath(6, path.size()), hasSegments(pathFactory, "dna:e", "..", ".."));
+ assertThat(path.subpath(7, path.size()), hasSegments(pathFactory, "..", ".."));
+ assertThat(path.subpath(8, path.size()), hasSegments(pathFactory, ".."));
- assertThat(path.subpath(0, 2), hasSegments(pathFactory, "dna:a", "b"));
- assertThat(path.subpath(1, 2), hasSegments(pathFactory, "b"));
- assertThat(path.subpath(1, 5), hasSegments(pathFactory, "b", "dna:c", "..", "d"));
- assertThat(path.subpath(2, 5), hasSegments(pathFactory, "dna:c", "..", "d"));
- assertThat(path.subpath(3, 5), hasSegments(pathFactory, "..", "d"));
- }
+ assertThat(path.subpath(0, 2), hasSegments(pathFactory, "dna:a", "b"));
+ assertThat(path.subpath(1, 2), hasSegments(pathFactory, "b"));
+ assertThat(path.subpath(1, 5), hasSegments(pathFactory, "b", "dna:c", "..", "d"));
+ assertThat(path.subpath(2, 5), hasSegments(pathFactory, "dna:c", "..", "d"));
+ assertThat(path.subpath(3, 5), hasSegments(pathFactory, "..", "d"));
+ }
- @Test
- public void shouldFindRelativePaths() {
- path = pathFactory.create("/a/b/c/d");
- assertThat(path.relativeTo(pathFactory.create("/a/e/f")), is(pathFactory.create("../../b/c/d")));
- assertThat(path.relativeTo(pathFactory.create("/e/f")), is(pathFactory.create("../../a/b/c/d")));
+ @Test
+ public void shouldFindRelativePaths() {
+ path = pathFactory.create("/a/b/c/d");
+ assertThat(path.relativeTo(pathFactory.create("/a/e/f")), is(pathFactory.create("../../b/c/d")));
+ assertThat(path.relativeTo(pathFactory.create("/e/f")), is(pathFactory.create("../../a/b/c/d")));
- }
+ }
- @Test( expected = InvalidPathException.class )
- public void shouldNotAllowFindingRelativePathsFromRelativePaths() {
- path = pathFactory.create("a/b/c/d");
- path.relativeTo(pathFactory.create("/e/f"));
+ @Test( expected = InvalidPathException.class )
+ public void shouldNotAllowFindingRelativePathsFromRelativePaths() {
+ path = pathFactory.create("a/b/c/d");
+ path.relativeTo(pathFactory.create("/e/f"));
- }
+ }
- @Test( expected = InvalidPathException.class )
- public void shouldNotResolveRelativePathToAnotherRelativePath() {
- path = pathFactory.create("/a/b/c/d");
- path.relativeTo(pathFactory.create("e/f"));
+ @Test( expected = InvalidPathException.class )
+ public void shouldNotResolveRelativePathToAnotherRelativePath() {
+ path = pathFactory.create("/a/b/c/d");
+ path.relativeTo(pathFactory.create("e/f"));
- }
+ }
- @Test( expected = InvalidPathException.class )
- public void shouldNotResolveRelativePathUsingAnAbsolutePath() {
- path = pathFactory.create("/a/b/c/d");
- path.resolve(pathFactory.create("/e/f"));
- }
+ @Test( expected = InvalidPathException.class )
+ public void shouldNotResolveRelativePathUsingAnAbsolutePath() {
+ path = pathFactory.create("/a/b/c/d");
+ path.resolve(pathFactory.create("/e/f"));
+ }
- @Test
- public void shouldResolveRelativePathToAbsolutePath() {
- path = pathFactory.create("/a/b/c/d");
- path2 = path.resolve(pathFactory.create("../../e/f"));
- assertThat(path2, is(pathFactory.create("/a/b/e/f")));
- assertThat(path2.isAbsolute(), is(true));
- assertThat(path2.isNormalized(), is(true));
- }
+ @Test
+ public void shouldResolveRelativePathToAbsolutePath() {
+ path = pathFactory.create("/a/b/c/d");
+ path2 = path.resolve(pathFactory.create("../../e/f"));
+ assertThat(path2, is(pathFactory.create("/a/b/e/f")));
+ assertThat(path2.isAbsolute(), is(true));
+ assertThat(path2.isNormalized(), is(true));
+ }
- @Test
- public void shouldOrderPathsCorrectly() {
- List<Path> paths = new ArrayList<Path>();
- paths.add(pathFactory.create("/a"));
- paths.add(pathFactory.create("/a/b"));
- paths.add(pathFactory.create("/a/b/alpha"));
- paths.add(pathFactory.create("/a/b/beta"));
- paths.add(pathFactory.create("/a/b/dna:mixinTypes"));
- paths.add(pathFactory.create("/a/b/dna:name"));
- paths.add(pathFactory.create("/a/b/dna:primaryType"));
- paths.add(pathFactory.create("/a/c[1]"));
- paths.add(pathFactory.create("/a/c[1]/alpha"));
- paths.add(pathFactory.create("/a/c[1]/beta"));
- paths.add(pathFactory.create("/a/c[1]/dna:mixinTypes"));
- paths.add(pathFactory.create("/a/c[1]/dna:name"));
- paths.add(pathFactory.create("/a/c[1]/dna:primaryType"));
- paths.add(pathFactory.create("/a/c[2]"));
- paths.add(pathFactory.create("/a/c[2]/alpha"));
- paths.add(pathFactory.create("/a/c[2]/beta"));
- paths.add(pathFactory.create("/a/c[2]/dna:mixinTypes"));
- paths.add(pathFactory.create("/a/c[2]/dna:name"));
- paths.add(pathFactory.create("/a/c[2]/dna:primaryType"));
+ @Test
+ public void shouldOrderPathsCorrectly() {
+ List<Path> paths = new ArrayList<Path>();
+ paths.add(pathFactory.create("/a"));
+ paths.add(pathFactory.create("/a/b"));
+ paths.add(pathFactory.create("/a/b/alpha"));
+ paths.add(pathFactory.create("/a/b/beta"));
+ paths.add(pathFactory.create("/a/b/dna:mixinTypes"));
+ paths.add(pathFactory.create("/a/b/dna:name"));
+ paths.add(pathFactory.create("/a/b/dna:primaryType"));
+ paths.add(pathFactory.create("/a/c[1]"));
+ paths.add(pathFactory.create("/a/c[1]/alpha"));
+ paths.add(pathFactory.create("/a/c[1]/beta"));
+ paths.add(pathFactory.create("/a/c[1]/dna:mixinTypes"));
+ paths.add(pathFactory.create("/a/c[1]/dna:name"));
+ paths.add(pathFactory.create("/a/c[1]/dna:primaryType"));
+ paths.add(pathFactory.create("/a/c[2]"));
+ paths.add(pathFactory.create("/a/c[2]/alpha"));
+ paths.add(pathFactory.create("/a/c[2]/beta"));
+ paths.add(pathFactory.create("/a/c[2]/dna:mixinTypes"));
+ paths.add(pathFactory.create("/a/c[2]/dna:name"));
+ paths.add(pathFactory.create("/a/c[2]/dna:primaryType"));
- // Randomize the list of paths, so we have something to sort ...
- List<Path> randomizedPaths = new ArrayList<Path>(paths);
- Collections.shuffle(randomizedPaths);
- assertThat(randomizedPaths, is(not(paths)));
+ // Randomize the list of paths, so we have something to sort ...
+ List<Path> randomizedPaths = new ArrayList<Path>(paths);
+ Collections.shuffle(randomizedPaths);
+ assertThat(randomizedPaths, is(not(paths)));
- // Sort ...
- Collections.sort(randomizedPaths);
- assertThat(randomizedPaths, is(paths));
- }
+ // Sort ...
+ Collections.sort(randomizedPaths);
+ assertThat(randomizedPaths, is(paths));
+ }
- @Test
- public void shouldGetNormalizedPathOfSelfShouldBeSame() {
- assertThat(pathFactory.create(".").getNormalizedPath(), is(pathFactory.create(".")));
- assertThat(pathFactory.create("./").getNormalizedPath(), is(pathFactory.create(".")));
- assertThat(pathFactory.create("./././").getNormalizedPath(), is(pathFactory.create(".")));
- }
+ @Test
+ public void shouldGetNormalizedPathOfSelfShouldBeSame() {
+ assertThat(pathFactory.create(".").getNormalizedPath(), is(pathFactory.create(".")));
+ assertThat(pathFactory.create("./").getNormalizedPath(), is(pathFactory.create(".")));
+ assertThat(pathFactory.create("./././").getNormalizedPath(), is(pathFactory.create(".")));
+ }
- @Test
- public void shouldGetNormalizedPathWithParentReferences() {
- assertThat(pathFactory.create("..").getNormalizedPath(), is(pathFactory.create("..")));
- assertThat(pathFactory.create("../").getNormalizedPath(), is(pathFactory.create("../")));
- assertThat(pathFactory.create("../../../../../..").getNormalizedPath(), is(pathFactory.create("../../../../../..")));
- }
+ @Test
+ public void shouldGetNormalizedPathWithParentReferences() {
+ assertThat(pathFactory.create("..").getNormalizedPath(), is(pathFactory.create("..")));
+ assertThat(pathFactory.create("../").getNormalizedPath(), is(pathFactory.create("../")));
+ assertThat(pathFactory.create("../../../../../..").getNormalizedPath(), is(pathFactory.create("../../../../../..")));
+ }
- @Test
- public void shouldGetRelativePathUsingSelf() {
- path = pathFactory.create("/a/b/c/d/e/f");
- assertThat(path.resolve(pathFactory.create(".")), is(sameInstance(path)));
- assertThat(path.resolve(pathFactory.create("././.")), is(sameInstance(path)));
- }
+ @Test
+ public void shouldGetRelativePathUsingSelf() {
+ path = pathFactory.create("/a/b/c/d/e/f");
+ assertThat(path.resolve(pathFactory.create(".")), is(sameInstance(path)));
+ assertThat(path.resolve(pathFactory.create("././.")), is(sameInstance(path)));
+ }
- @Test
- public void shouldResolveRelativePathToParent() {
- path = pathFactory.create("/a/b/c/d/e/f");
- assertThat(path.resolve(pathFactory.create("..")), is(path.getAncestor()));
- assertThat(path.resolve(pathFactory.create("..")), hasSegments(pathFactory, "a", "b", "c", "d", "e"));
- }
+ @Test
+ public void shouldResolveRelativePathToParent() {
+ path = pathFactory.create("/a/b/c/d/e/f");
+ assertThat(path.resolve(pathFactory.create("..")), is(path.getAncestor()));
+ assertThat(path.resolve(pathFactory.create("..")), hasSegments(pathFactory, "a", "b", "c", "d", "e"));
+ }
- @Test
- public void shouldResolveRelativePaths() {
- path = pathFactory.create("/a/b/c/d/e/f");
- assertThat(path.resolve(pathFactory.create("../../../../../..")), is(sameInstance(ROOT)));
- assertThat(path.resolve(pathFactory.create("../..")), is(path.getAncestor().getAncestor()));
- assertThat(path.resolve(pathFactory.create("../..")), hasSegments(pathFactory, "a", "b", "c", "d"));
- assertThat(path.resolve(pathFactory.create("../x/../y/../z/..")), is(path.getAncestor()));
- assertThat(path.resolve(pathFactory.create("../x/../y/../z/..")), hasSegments(pathFactory, "a", "b", "c", "d", "e"));
- assertThat(path.resolve(pathFactory.create("../x")), hasSegments(pathFactory, "a", "b", "c", "d", "e", "x"));
- }
+ @Test
+ public void shouldResolveRelativePaths() {
+ path = pathFactory.create("/a/b/c/d/e/f");
+ assertThat(path.resolve(pathFactory.create("../../../../../..")), is(sameInstance(ROOT)));
+ assertThat(path.resolve(pathFactory.create("../..")), is(path.getAncestor().getAncestor()));
+ assertThat(path.resolve(pathFactory.create("../..")), hasSegments(pathFactory, "a", "b", "c", "d"));
+ assertThat(path.resolve(pathFactory.create("../x/../y/../z/..")), is(path.getAncestor()));
+ assertThat(path.resolve(pathFactory.create("../x/../y/../z/..")), hasSegments(pathFactory, "a", "b", "c", "d", "e"));
+ assertThat(path.resolve(pathFactory.create("../x")), hasSegments(pathFactory, "a", "b", "c", "d", "e", "x"));
+ }
- public void shouldResolveNonAbsolutePaths() {
- path = pathFactory.create("a/b/c");
- assertThat(path, hasSegments(pathFactory, "a", "b", "c"));
- }
+ public void shouldResolveNonAbsolutePaths() {
+ path = pathFactory.create("a/b/c");
+ assertThat(path, hasSegments(pathFactory, "a", "b", "c"));
+ }
}
Modified: trunk/dna-spi/src/test/java/org/jboss/dna/spi/graph/impl/BooleanValueFactoryTest.java
===================================================================
--- trunk/dna-spi/src/test/java/org/jboss/dna/spi/graph/impl/BooleanValueFactoryTest.java 2008-06-02 20:19:51 UTC (rev 234)
+++ trunk/dna-spi/src/test/java/org/jboss/dna/spi/graph/impl/BooleanValueFactoryTest.java 2008-06-03 17:32:57 UTC (rev 235)
@@ -28,7 +28,6 @@
import java.net.URI;
import java.util.Calendar;
import java.util.Date;
-import org.jboss.dna.common.text.TextEncoder;
import org.jboss.dna.spi.graph.Name;
import org.jboss.dna.spi.graph.Path;
import org.jboss.dna.spi.graph.Reference;
@@ -51,9 +50,8 @@
*/
@Before
public void setUp() throws Exception {
- TextEncoder encoder = Path.URL_ENCODER;
- stringFactory = new StringValueFactory(encoder);
- factory = new BooleanValueFactory(encoder, stringFactory);
+ stringFactory = new StringValueFactory(Path.URL_DECODER, Path.DEFAULT_ENCODER);
+ factory = new BooleanValueFactory(Path.URL_DECODER, stringFactory);
context = new Mockery();
}
Modified: trunk/dna-spi/src/test/java/org/jboss/dna/spi/graph/impl/DecimalValueFactoryTest.java
===================================================================
--- trunk/dna-spi/src/test/java/org/jboss/dna/spi/graph/impl/DecimalValueFactoryTest.java 2008-06-02 20:19:51 UTC (rev 234)
+++ trunk/dna-spi/src/test/java/org/jboss/dna/spi/graph/impl/DecimalValueFactoryTest.java 2008-06-03 17:32:57 UTC (rev 235)
@@ -29,7 +29,6 @@
import java.net.URI;
import java.util.Calendar;
import java.util.Date;
-import org.jboss.dna.common.text.TextEncoder;
import org.jboss.dna.spi.graph.Name;
import org.jboss.dna.spi.graph.Path;
import org.jboss.dna.spi.graph.Reference;
@@ -52,9 +51,8 @@
*/
@Before
public void setUp() throws Exception {
- TextEncoder encoder = Path.URL_ENCODER;
- stringFactory = new StringValueFactory(encoder);
- factory = new DecimalValueFactory(encoder, stringFactory);
+ stringFactory = new StringValueFactory(Path.URL_DECODER, Path.DEFAULT_ENCODER);
+ factory = new DecimalValueFactory(Path.URL_DECODER, stringFactory);
context = new Mockery();
}
Modified: trunk/dna-spi/src/test/java/org/jboss/dna/spi/graph/impl/DoubleValueFactoryTest.java
===================================================================
--- trunk/dna-spi/src/test/java/org/jboss/dna/spi/graph/impl/DoubleValueFactoryTest.java 2008-06-02 20:19:51 UTC (rev 234)
+++ trunk/dna-spi/src/test/java/org/jboss/dna/spi/graph/impl/DoubleValueFactoryTest.java 2008-06-03 17:32:57 UTC (rev 235)
@@ -29,7 +29,6 @@
import java.net.URI;
import java.util.Calendar;
import java.util.Date;
-import org.jboss.dna.common.text.TextEncoder;
import org.jboss.dna.spi.graph.Name;
import org.jboss.dna.spi.graph.Path;
import org.jboss.dna.spi.graph.Reference;
@@ -52,9 +51,8 @@
*/
@Before
public void setUp() throws Exception {
- TextEncoder encoder = Path.URL_ENCODER;
- stringFactory = new StringValueFactory(encoder);
- factory = new DoubleValueFactory(encoder, stringFactory);
+ stringFactory = new StringValueFactory(Path.URL_DECODER, Path.URL_ENCODER);
+ factory = new DoubleValueFactory(Path.URL_DECODER, stringFactory);
context = new Mockery();
}
Modified: trunk/dna-spi/src/test/java/org/jboss/dna/spi/graph/impl/InMemoryBinaryValueFactoryTest.java
===================================================================
--- trunk/dna-spi/src/test/java/org/jboss/dna/spi/graph/impl/InMemoryBinaryValueFactoryTest.java 2008-06-02 20:19:51 UTC (rev 234)
+++ trunk/dna-spi/src/test/java/org/jboss/dna/spi/graph/impl/InMemoryBinaryValueFactoryTest.java 2008-06-03 17:32:57 UTC (rev 235)
@@ -56,13 +56,13 @@
@Before
public void setUp() throws Exception {
encoder = Path.URL_ENCODER;
- stringFactory = new StringValueFactory(encoder);
- factory = new InMemoryBinaryValueFactory(encoder, stringFactory);
+ stringFactory = new StringValueFactory(Path.URL_DECODER, encoder);
+ factory = new InMemoryBinaryValueFactory(Path.URL_DECODER, stringFactory);
namespaceRegistry = new BasicNamespaceRegistry();
namespaceRegistry.register("jboss", "http://www.jboss.org");
namespaceRegistry.register("dna", "http://www.jboss.org/dna");
- nameFactory = new NameValueFactory(namespaceRegistry, encoder, stringFactory);
- pathFactory = new PathValueFactory(encoder, stringFactory, nameFactory);
+ nameFactory = new NameValueFactory(namespaceRegistry, Path.URL_DECODER, stringFactory);
+ pathFactory = new PathValueFactory(Path.URL_DECODER, stringFactory, nameFactory);
}
@Test
Modified: trunk/dna-spi/src/test/java/org/jboss/dna/spi/graph/impl/JodaDateTimeValueFactoryTest.java
===================================================================
--- trunk/dna-spi/src/test/java/org/jboss/dna/spi/graph/impl/JodaDateTimeValueFactoryTest.java 2008-06-02 20:19:51 UTC (rev 234)
+++ trunk/dna-spi/src/test/java/org/jboss/dna/spi/graph/impl/JodaDateTimeValueFactoryTest.java 2008-06-03 17:32:57 UTC (rev 235)
@@ -28,7 +28,6 @@
import java.math.BigDecimal;
import java.net.URI;
import java.util.Calendar;
-import org.jboss.dna.common.text.TextEncoder;
import org.jboss.dna.spi.graph.DateTime;
import org.jboss.dna.spi.graph.Name;
import org.jboss.dna.spi.graph.Path;
@@ -61,9 +60,8 @@
*/
@Before
public void setUp() throws Exception {
- TextEncoder encoder = Path.URL_ENCODER;
- stringFactory = new StringValueFactory(encoder);
- factory = new JodaDateTimeValueFactory(encoder, stringFactory);
+ stringFactory = new StringValueFactory(Path.URL_DECODER, Path.URL_ENCODER);
+ factory = new JodaDateTimeValueFactory(Path.URL_DECODER, stringFactory);
context = new Mockery();
}
Modified: trunk/dna-spi/src/test/java/org/jboss/dna/spi/graph/impl/LongValueFactoryTest.java
===================================================================
--- trunk/dna-spi/src/test/java/org/jboss/dna/spi/graph/impl/LongValueFactoryTest.java 2008-06-02 20:19:51 UTC (rev 234)
+++ trunk/dna-spi/src/test/java/org/jboss/dna/spi/graph/impl/LongValueFactoryTest.java 2008-06-03 17:32:57 UTC (rev 235)
@@ -29,7 +29,6 @@
import java.net.URI;
import java.util.Calendar;
import java.util.Date;
-import org.jboss.dna.common.text.TextEncoder;
import org.jboss.dna.spi.graph.Name;
import org.jboss.dna.spi.graph.Path;
import org.jboss.dna.spi.graph.Reference;
@@ -52,9 +51,8 @@
*/
@Before
public void setUp() throws Exception {
- TextEncoder encoder = Path.URL_ENCODER;
- stringFactory = new StringValueFactory(encoder);
- factory = new LongValueFactory(encoder, stringFactory);
+ stringFactory = new StringValueFactory(Path.URL_DECODER, Path.URL_ENCODER);
+ factory = new LongValueFactory(Path.URL_DECODER, stringFactory);
context = new Mockery();
}
Modified: trunk/dna-spi/src/test/java/org/jboss/dna/spi/graph/impl/NameValueFactoryTest.java
===================================================================
--- trunk/dna-spi/src/test/java/org/jboss/dna/spi/graph/impl/NameValueFactoryTest.java 2008-06-02 20:19:51 UTC (rev 234)
+++ trunk/dna-spi/src/test/java/org/jboss/dna/spi/graph/impl/NameValueFactoryTest.java 2008-06-03 17:32:57 UTC (rev 235)
@@ -23,6 +23,7 @@
import static org.hamcrest.core.Is.is;
import static org.junit.Assert.assertThat;
+import org.jboss.dna.common.text.TextDecoder;
import org.jboss.dna.common.text.TextEncoder;
import org.jboss.dna.spi.graph.Name;
import org.jboss.dna.spi.graph.NamespaceRegistry;
@@ -37,84 +38,86 @@
*/
public class NameValueFactoryTest {
- public static final TextEncoder NO_OP_ENCODER = Path.NO_OP_ENCODER;
+ public static final TextEncoder NO_OP_ENCODER = Path.NO_OP_ENCODER;
- private NamespaceRegistry registry;
- private ValueFactory<String> stringValueFactory;
- private NameValueFactory factory;
- private TextEncoder encoder;
- private Name name;
+ private NamespaceRegistry registry;
+ private ValueFactory<String> stringValueFactory;
+ private NameValueFactory factory;
+ private TextEncoder encoder;
+ private TextDecoder decoder;
+ private Name name;
- @Before
- public void beforeEach() throws Exception {
- this.registry = new BasicNamespaceRegistry();
- this.registry.register("dna", "http://www.jboss.org/dna/namespace");
- this.encoder = Path.DEFAULT_ENCODER;
- this.stringValueFactory = new StringValueFactory(encoder);
- this.factory = new NameValueFactory(registry, encoder, stringValueFactory);
- }
+ @Before
+ public void beforeEach() throws Exception {
+ this.registry = new BasicNamespaceRegistry();
+ this.registry.register("dna", "http://www.jboss.org/dna/namespace");
+ this.encoder = Path.DEFAULT_ENCODER;
+ this.decoder = Path.DEFAULT_DECODER;
+ this.stringValueFactory = new StringValueFactory(decoder, encoder);
+ this.factory = new NameValueFactory(registry, decoder, stringValueFactory);
+ }
- @Test
- public void shouldCreateNameFromSingleStringInPrefixedNamespaceFormatWithoutPrefix() {
- name = factory.create("a");
- assertThat(name.getLocalName(), is("a"));
- assertThat(name.getNamespaceUri(), is(this.registry.getNamespaceForPrefix("")));
- }
+ @Test
+ public void shouldCreateNameFromSingleStringInPrefixedNamespaceFormatWithoutPrefix() {
+ name = factory.create("a");
+ assertThat(name.getLocalName(), is("a"));
+ assertThat(name.getNamespaceUri(), is(this.registry.getNamespaceForPrefix("")));
+ }
- @Test
- public void shouldCreateNameFromSingleStringInPrefixedNamespaceFormat() {
- name = factory.create("dna:something");
- assertThat(name.getLocalName(), is("something"));
- assertThat(name.getNamespaceUri(), is("http://www.jboss.org/dna/namespace"));
- assertThat(name.getString(NO_OP_ENCODER), is("{http://www.jboss.org/dna/namespace}something"));
- }
+ @Test
+ public void shouldCreateNameFromSingleStringInPrefixedNamespaceFormat() {
+ name = factory.create("dna:something");
+ assertThat(name.getLocalName(), is("something"));
+ assertThat(name.getNamespaceUri(), is("http://www.jboss.org/dna/namespace"));
+ assertThat(name.getString(NO_OP_ENCODER), is("{http://www.jboss.org/dna/namespace}something"));
+ }
- @Test
- public void shouldCreateNameFromSingleEncodedStringInPrefixedNamespaceFormat() {
- name = factory.create(encoder.encode("dna") + ":" + encoder.encode("some/thing"));
- assertThat(name.getLocalName(), is("some/thing"));
- assertThat(name.getNamespaceUri(), is("http://www.jboss.org/dna/namespace"));
- assertThat(name.getString(NO_OP_ENCODER), is("{http://www.jboss.org/dna/namespace}some/thing"));
- }
+ @Test
+ public void shouldCreateNameFromSingleEncodedStringInPrefixedNamespaceFormat() {
+ name = factory.create(encoder.encode("dna") + ":" + encoder.encode("some/thing"));
+ assertThat(name.getLocalName(), is("some/thing"));
+ assertThat(name.getNamespaceUri(), is("http://www.jboss.org/dna/namespace"));
+ assertThat(name.getString(NO_OP_ENCODER), is("{http://www.jboss.org/dna/namespace}some/thing"));
+ }
- @Test
- public void shouldCreateNameFromSingleStringInStandardFullNamespaceFormat() {
- name = factory.create("{http://www.jboss.org/dna/namespace}something");
- assertThat(name.getLocalName(), is("something"));
- assertThat(name.getNamespaceUri(), is("http://www.jboss.org/dna/namespace"));
- assertThat(name.getString(NO_OP_ENCODER), is("{http://www.jboss.org/dna/namespace}something"));
- }
+ @Test
+ public void shouldCreateNameFromSingleStringInStandardFullNamespaceFormat() {
+ name = factory.create("{http://www.jboss.org/dna/namespace}something");
+ assertThat(name.getLocalName(), is("something"));
+ assertThat(name.getNamespaceUri(), is("http://www.jboss.org/dna/namespace"));
+ assertThat(name.getString(NO_OP_ENCODER), is("{http://www.jboss.org/dna/namespace}something"));
+ }
- @Test
- public void shouldCreateNameFromSingleEncodedStringInStandardFullNamespaceFormat() {
- name = factory.create("{" + encoder.encode("http://www.jboss.org/dna/namespace") + "}" + encoder.encode("some/thing"));
- assertThat(name.getLocalName(), is("some/thing"));
- assertThat(name.getNamespaceUri(), is("http://www.jboss.org/dna/namespace"));
- assertThat(name.getString(NO_OP_ENCODER), is("{http://www.jboss.org/dna/namespace}some/thing"));
- }
+ @Test
+ public void shouldCreateNameFromSingleEncodedStringInStandardFullNamespaceFormat() {
+ name = factory.create("{" + encoder.encode("http://www.jboss.org/dna/namespace") + "}" + encoder.encode("some/thing"));
+ assertThat(name.getLocalName(), is("some/thing"));
+ assertThat(name.getNamespaceUri(), is("http://www.jboss.org/dna/namespace"));
+ assertThat(name.getString(NO_OP_ENCODER), is("{http://www.jboss.org/dna/namespace}some/thing"));
+ }
- @Test
- public void shouldProvideAccessToNamespaceRegistryPassedInConstructor() {
- assertThat(factory.getNamespaceRegistry(), is(registry));
- }
+ @Test
+ public void shouldProvideAccessToNamespaceRegistryPassedInConstructor() {
+ assertThat(factory.getNamespaceRegistry(), is(registry));
+ }
- @Test( expected = IllegalArgumentException.class )
- public void shouldNotAllowNullLocalName() {
- factory.create("a", (String)null);
- }
+ @Test( expected = IllegalArgumentException.class )
+ public void shouldNotAllowNullLocalName() {
+ factory.create("a", (String)null);
+ }
- @Test( expected = IllegalArgumentException.class )
- public void shouldNotAllowNullLocalNameWithEncoder() {
- factory.create("a", null, encoder);
- }
+ @Test( expected = IllegalArgumentException.class )
+ public void shouldNotAllowNullLocalNameWithEncoder() {
+ factory.create("a", null, decoder);
+ }
- @Test( expected = IllegalArgumentException.class )
- public void shouldNotAllowEmptyLocalName() {
- factory.create("a", "");
- }
+ @Test( expected = IllegalArgumentException.class )
+ public void shouldNotAllowEmptyLocalName() {
+ factory.create("a", "");
+ }
- @Test( expected = IllegalArgumentException.class )
- public void shouldNotAllowEmptyLocalNameWithEncoder() {
- factory.create("a", "", encoder);
- }
+ @Test( expected = IllegalArgumentException.class )
+ public void shouldNotAllowEmptyLocalNameWithEncoder() {
+ factory.create("a", "", decoder);
+ }
}
Modified: trunk/dna-spi/src/test/java/org/jboss/dna/spi/graph/impl/PathValueFactoryTest.java
===================================================================
--- trunk/dna-spi/src/test/java/org/jboss/dna/spi/graph/impl/PathValueFactoryTest.java 2008-06-02 20:19:51 UTC (rev 234)
+++ trunk/dna-spi/src/test/java/org/jboss/dna/spi/graph/impl/PathValueFactoryTest.java 2008-06-03 17:32:57 UTC (rev 235)
@@ -44,7 +44,6 @@
private ValueFactory<String> stringValueFactory;
private NameValueFactory nameFactory;
private PathValueFactory factory;
- private TextEncoder encoder;
private Path path;
private Path path2;
@@ -52,10 +51,9 @@
public void beforeEach() throws Exception {
this.registry = new BasicNamespaceRegistry();
this.registry.register("dna", "http://www.jboss.org/dna/namespace");
- this.encoder = Path.DEFAULT_ENCODER;
- this.stringValueFactory = new StringValueFactory(encoder);
- this.nameFactory = new NameValueFactory(registry, encoder, stringValueFactory);
- this.factory = new PathValueFactory(encoder, stringValueFactory, nameFactory);
+ this.stringValueFactory = new StringValueFactory(Path.DEFAULT_DECODER, Path.DEFAULT_ENCODER);
+ this.nameFactory = new NameValueFactory(registry, Path.DEFAULT_DECODER, stringValueFactory);
+ this.factory = new PathValueFactory(Path.DEFAULT_DECODER, stringValueFactory, nameFactory);
}
protected List<Path.Segment> getSegments( String... segments ) {
More information about the dna-commits
mailing list