Author: jverhaeg(a)redhat.com Date: 2008-06-02 16:08:01 -0400 (Mon, 02 Jun 2008) New Revision: 231 Modified: trunk/dna-spi/src/main/java/org/jboss/dna/spi/SpiI18n.java trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/BasicPath.java trunk/dna-spi/src/main/resources/org/jboss/dna/spi/SpiI18n.properties Log: DNA-92: Corrected misspelling Modified: trunk/dna-spi/src/main/java/org/jboss/dna/spi/SpiI18n.java =================================================================== --- trunk/dna-spi/src/main/java/org/jboss/dna/spi/SpiI18n.java 2008-06-02 19:56:43 UTC (rev 230) +++ trunk/dna-spi/src/main/java/org/jboss/dna/spi/SpiI18n.java 2008-06-02 20:08:01 UTC (rev 231) @@ -2,7 +2,7 @@ * 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. + * 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 @@ -28,29 +28,29 @@ /** * @author Randall Hauch + * @author John Verhaeg */ public final class SpiI18n { - public static I18n unableToDiscoverPropertyTypeForNullValue; - public static I18n errorReadingPropertyValueBytes; - public static I18n valueJavaTypeNotCompatibleWithPropertyType; - public static I18n errorConvertingBinaryValueToString; public static I18n errorCreatingValue; - public static I18n unableToCreateValue; - public static I18n validPathMayNotContainEmptySegment; + public static I18n errorReadingPropertyValueBytes; + public static I18n invalidIndexInSegmentName; + public static I18n invalidQualifiedNameString; + public static I18n missingEndBracketInSegmentName; public static I18n noNamespaceRegisteredForPrefix; - public static I18n pathAncestorDegreeIsInvalid; + public static I18n pathCannotBeNormalized; public static I18n pathIsAlreadyAbsolute; public static I18n pathIsNotAbsolute; public static I18n pathIsNotRelative; - public static I18n pathCannotBeNormalized; - public static I18n unbleToCreateSubpathBeginIndexGreaterThanOrEqualToSize; - public static I18n unbleToCreateSubpathBeginIndexGreaterThanOrEqualToEndingIndex; + public static I18n unableToCreateSubpathBeginIndexGreaterThanOrEqualToEndingIndex; + public static I18n unableToCreateSubpathBeginIndexGreaterThanOrEqualToSize; + public static I18n unableToCreateValue; + public static I18n unableToDiscoverPropertyTypeForNullValue; + public static I18n validPathMayNotContainEmptySegment; + public static I18n valueJavaTypeNotCompatibleWithPropertyType; - public static I18n invalidQualifiedNameString; - public static I18n maximumPoolSizeMayNotBeSmallerThanCorePoolSize; public static I18n repositoryConnectionPoolIsNotRunning; public static I18n unableToObtainValidRepositoryAfterAttempts; Modified: trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/BasicPath.java =================================================================== --- trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/BasicPath.java 2008-06-02 19:56:43 UTC (rev 230) +++ trunk/dna-spi/src/main/java/org/jboss/dna/spi/graph/impl/BasicPath.java 2008-06-02 20:08:01 UTC (rev 231) @@ -2,7 +2,7 @@ * 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. + * 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 @@ -39,459 +39,470 @@ /** * A basic implementation of {@link Path}. + * * @author Randall Hauch + * @author John Verhaeg */ @Immutable public class BasicPath implements Path { - private static final List<Segment> EMPTY_SEGMENTS = Collections.emptyList(); + private static final List<Segment> EMPTY_SEGMENTS = Collections.emptyList(); - public static final Path ROOT = new BasicPath(EMPTY_SEGMENTS, true); + public static final Path ROOT = new BasicPath(EMPTY_SEGMENTS, true); - protected static final Path SELF_PATH = new BasicPath(Collections.singletonList(Path.SELF_SEGMENT), false); + protected static final Path SELF_PATH = new BasicPath(Collections.singletonList(Path.SELF_SEGMENT), false); - private final List<Segment> segments; - private final boolean absolute; - private final boolean normalized; - private transient String path; + private final List<Segment> segments; + private final boolean absolute; + private final boolean normalized; + private transient String path; - /** - * @param segments the segments - * @param absolute true if this path is absolute, or false otherwise - */ - public BasicPath( List<Segment> segments, boolean absolute ) { - ArgCheck.isNotNull(segments, "segments"); - this.segments = segments.isEmpty() ? EMPTY_SEGMENTS : Collections.unmodifiableList(segments); - this.absolute = absolute; - this.normalized = isNormalized(this.segments); - } + /** + * @param segments the segments + * @param absolute true if this path is absolute, or false otherwise + */ + public BasicPath( List<Segment> segments, + boolean absolute ) { + ArgCheck.isNotNull(segments, "segments"); + this.segments = segments.isEmpty() ? EMPTY_SEGMENTS : Collections.unmodifiableList(segments); + this.absolute = absolute; + this.normalized = isNormalized(this.segments); + } - protected boolean isNormalized( List<Segment> segments ) { - for (Segment segment : segments) { - if (segment.isSelfReference() || segment.isParentReference()) return false; - } - return true; - } + protected boolean isNormalized( List<Segment> segments ) { + for (Segment segment : segments) { + if (segment.isSelfReference() || segment.isParentReference()) return false; + } + return true; + } - /** - * {@inheritDoc} - */ - public Path getAncestor() { - if (this.isRoot()) return this; - if (this.segments.size() == 1) return ROOT; - return subpath(0, this.segments.size() - 1); - } + /** + * {@inheritDoc} + */ + public Path getAncestor() { + if (this.isRoot()) return this; + if (this.segments.size() == 1) return ROOT; + return subpath(0, this.segments.size() - 1); + } - /** - * {@inheritDoc} - */ - public Path getAncestor( int degree ) { - ArgCheck.isNonNegative(degree, "degree"); - if (this.isRoot()) return this; - if (degree == 0) return this; - int endIndex = this.segments.size() - degree; - if (endIndex < 0) { - String msg = SpiI18n.pathAncestorDegreeIsInvalid.text(this.getString(), Inflector.getInstance().ordinalize(degree)); - throw new PathNotFoundException(msg); - } - return subpath(0, endIndex); - } + /** + * {@inheritDoc} + */ + public Path getAncestor( int degree ) { + ArgCheck.isNonNegative(degree, "degree"); + if (this.isRoot()) return this; + if (degree == 0) return this; + int endIndex = this.segments.size() - degree; + if (endIndex < 0) { + String msg = SpiI18n.pathAncestorDegreeIsInvalid.text(this.getString(), Inflector.getInstance().ordinalize(degree)); + throw new PathNotFoundException(msg); + } + return subpath(0, endIndex); + } - /** - * {@inheritDoc} - */ - public Path getCanonicalPath() { - if (!this.isAbsolute()) { - String msg = SpiI18n.pathIsNotAbsolute.text(this); - throw new InvalidPathException(msg); - } - if (this.isNormalized()) return this; - return this.getNormalizedPath(); - } + /** + * {@inheritDoc} + */ + public Path getCanonicalPath() { + if (!this.isAbsolute()) { + String msg = SpiI18n.pathIsNotAbsolute.text(this); + throw new InvalidPathException(msg); + } + if (this.isNormalized()) return this; + return this.getNormalizedPath(); + } - /** - * {@inheritDoc} - */ - public Path getCommonAncestor( Path that ) { - if (that == null) return null; - if (this.isRoot() || that.isRoot()) return ROOT; - Path normalizedPath = this.getNormalizedPath(); - int lastIndex = 0; - Iterator<Segment> thisIter = normalizedPath.iterator(); - Iterator<Segment> thatIter = that.getNormalizedPath().iterator(); - while (thisIter.hasNext() && thatIter.hasNext()) { - Segment thisSeg = thisIter.next(); - Segment thatSeg = thatIter.next(); - if (thisSeg.equals(thatSeg)) { - ++lastIndex; - } else { - break; - } - } - if (lastIndex == 0) return ROOT; - return normalizedPath.subpath(0, lastIndex); - } + /** + * {@inheritDoc} + */ + public Path getCommonAncestor( Path that ) { + if (that == null) return null; + if (this.isRoot() || that.isRoot()) return ROOT; + Path normalizedPath = this.getNormalizedPath(); + int lastIndex = 0; + Iterator<Segment> thisIter = normalizedPath.iterator(); + Iterator<Segment> thatIter = that.getNormalizedPath().iterator(); + while (thisIter.hasNext() && thatIter.hasNext()) { + Segment thisSeg = thisIter.next(); + Segment thatSeg = thatIter.next(); + if (thisSeg.equals(thatSeg)) { + ++lastIndex; + } else { + break; + } + } + if (lastIndex == 0) return ROOT; + return normalizedPath.subpath(0, lastIndex); + } - /** - * {@inheritDoc} - */ - public Path.Segment getLastSegment() { - if (this.isRoot()) return null; - return this.segments.get(size() - 1); - } + /** + * {@inheritDoc} + */ + public Path.Segment getLastSegment() { + if (this.isRoot()) return null; + return this.segments.get(size() - 1); + } - /** - * {@inheritDoc} - */ - public Path getNormalizedPath() { - if (this.isNormalized()) return this; // ROOT is normalized already - LinkedList<Segment> newSegments = new LinkedList<Segment>(); - for (Segment segment : segments) { - if (segment.isSelfReference()) continue; - if (segment.isParentReference()) { - if (newSegments.isEmpty()) { - if (this.isAbsolute()) { - throw new InvalidPathException(CommonI18n.pathCannotBeNormalized.text(this)); - } - } else if (!newSegments.getLast().isParentReference()) { - newSegments.removeLast(); - continue; - } - } - newSegments.add(segment); - } - if (newSegments.isEmpty()) { - if (this.isAbsolute()) return ROOT; - // Otherwise relative and it had contained nothing but self references ... - return SELF_PATH; - } - return new BasicPath(newSegments, this.isAbsolute()); - } + /** + * {@inheritDoc} + */ + public Path getNormalizedPath() { + if (this.isNormalized()) return this; // ROOT is normalized already + LinkedList<Segment> newSegments = new LinkedList<Segment>(); + for (Segment segment : segments) { + if (segment.isSelfReference()) continue; + if (segment.isParentReference()) { + if (newSegments.isEmpty()) { + if (this.isAbsolute()) { + throw new InvalidPathException(CommonI18n.pathCannotBeNormalized.text(this)); + } + } else if (!newSegments.getLast().isParentReference()) { + newSegments.removeLast(); + continue; + } + } + newSegments.add(segment); + } + if (newSegments.isEmpty()) { + if (this.isAbsolute()) return ROOT; + // Otherwise relative and it had contained nothing but self references ... + return SELF_PATH; + } + return new BasicPath(newSegments, this.isAbsolute()); + } - /** - * {@inheritDoc} - */ - public Segment getSegment( int index ) { - return this.segments.get(index); - } + /** + * {@inheritDoc} + */ + public Segment getSegment( int index ) { + return this.segments.get(index); + } - /** - * {@inheritDoc} - */ - public Segment[] getSegmentsArray() { - return this.segments.toArray(new Path.Segment[this.segments.size()]); - } + /** + * {@inheritDoc} + */ + public Segment[] getSegmentsArray() { + return this.segments.toArray(new Path.Segment[this.segments.size()]); + } - /** - * {@inheritDoc} - */ - public List<Segment> getSegmentsList() { - return this.segments; - } + /** + * {@inheritDoc} + */ + public List<Segment> getSegmentsList() { + return this.segments; + } - /** - * {@inheritDoc} - */ - public String getString() { - return doGetString(null, DEFAULT_ENCODER); - } + /** + * {@inheritDoc} + */ + public String getString() { + return doGetString(null, DEFAULT_ENCODER); + } - /** - * {@inheritDoc} - */ - public String getString( TextEncoder encoder ) { - return doGetString(null, encoder); - } + /** + * {@inheritDoc} + */ + public String getString( TextEncoder encoder ) { + return doGetString(null, encoder); + } - /** - * {@inheritDoc} - */ - public String getString( NamespaceRegistry namespaceRegistry ) { - ArgCheck.isNotNull(namespaceRegistry, "namespaceRegistry"); - return doGetString(namespaceRegistry, null); - } + /** + * {@inheritDoc} + */ + public String getString( NamespaceRegistry namespaceRegistry ) { + ArgCheck.isNotNull(namespaceRegistry, "namespaceRegistry"); + return doGetString(namespaceRegistry, null); + } - /** - * {@inheritDoc} - */ - public String getString( NamespaceRegistry namespaceRegistry, TextEncoder encoder ) { - ArgCheck.isNotNull(namespaceRegistry, "namespaceRegistry"); - return doGetString(namespaceRegistry, encoder); - } + /** + * {@inheritDoc} + */ + public String getString( NamespaceRegistry namespaceRegistry, + TextEncoder encoder ) { + ArgCheck.isNotNull(namespaceRegistry, "namespaceRegistry"); + return doGetString(namespaceRegistry, encoder); + } - /** - * Method that creates the string representation. This method works two different ways depending upon whether the namespace - * registry is provided. - * @param namespaceRegistry - * @param encoder - * @return - */ - protected String doGetString( NamespaceRegistry namespaceRegistry, TextEncoder encoder ) { - if (encoder == null) encoder = DEFAULT_ENCODER; - if (encoder == DEFAULT_ENCODER && this.path != null) return this.path; + /** + * Method that creates the string representation. This method works two different ways depending upon whether the namespace + * registry is provided. + * + * @param namespaceRegistry + * @param encoder + * @return + */ + protected String doGetString( NamespaceRegistry namespaceRegistry, + TextEncoder encoder ) { + if (encoder == null) encoder = DEFAULT_ENCODER; + if (encoder == DEFAULT_ENCODER && this.path != null) return this.path; - // Since the segments are immutable, this code need not be synchronized because concurrent threads - // may just compute the same value (with no harm done) - StringBuilder sb = new StringBuilder(); - if (this.isAbsolute()) sb.append(DELIMITER); - boolean first = true; - for (Segment segment : this.segments) { - if (first) { - first = false; - } else { - sb.append(DELIMITER); - } - assert segment != null; - if (namespaceRegistry != null) { - sb.append(segment.getString(namespaceRegistry, encoder)); - } else { - sb.append(segment.getString(encoder)); - } - } - String result = sb.toString(); - // Save the result to the internal string if this the default encoder is used. - // This is not synchronized, but it's okay - if (encoder == DEFAULT_ENCODER && this.path == null) this.path = result; - return result; - } + // Since the segments are immutable, this code need not be synchronized because concurrent threads + // may just compute the same value (with no harm done) + StringBuilder sb = new StringBuilder(); + if (this.isAbsolute()) sb.append(DELIMITER); + boolean first = true; + for (Segment segment : this.segments) { + if (first) { + first = false; + } else { + sb.append(DELIMITER); + } + assert segment != null; + if (namespaceRegistry != null) { + sb.append(segment.getString(namespaceRegistry, encoder)); + } else { + sb.append(segment.getString(encoder)); + } + } + String result = sb.toString(); + // Save the result to the internal string if this the default encoder is used. + // This is not synchronized, but it's okay + if (encoder == DEFAULT_ENCODER && this.path == null) this.path = result; + return result; + } - /** - * {@inheritDoc} - */ - public boolean hasSameAncestor( Path that ) { - if (that == null) return false; - if (that.size() != this.size()) return false; - if (this.size() == 1) return false; - for (int i = this.size() - 2; i < 0; --i) { - Path.Segment thisSegment = this.getSegment(i); - Path.Segment thatSegment = that.getSegment(i); - if (!thisSegment.equals(thatSegment)) return false; - } - return true; - } + /** + * {@inheritDoc} + */ + public boolean hasSameAncestor( Path that ) { + if (that == null) return false; + if (that.size() != this.size()) return false; + if (this.size() == 1) return false; + for (int i = this.size() - 2; i < 0; --i) { + Path.Segment thisSegment = this.getSegment(i); + Path.Segment thatSegment = that.getSegment(i); + if (!thisSegment.equals(thatSegment)) return false; + } + return true; + } - /** - * {@inheritDoc} - */ - public boolean isAbsolute() { - return this.absolute; - } + /** + * {@inheritDoc} + */ + public boolean isAbsolute() { + return this.absolute; + } - /** - * {@inheritDoc} - */ - public boolean isAncestorOf( Path decendant ) { - if (decendant == null) return false; - if (this == decendant) return false; - if (this.size() >= decendant.size()) return false; + /** + * {@inheritDoc} + */ + public boolean isAncestorOf( Path decendant ) { + if (decendant == null) return false; + if (this == decendant) return false; + if (this.size() >= decendant.size()) return false; - Iterator<Path.Segment> thisIter = this.iterator(); - Iterator<Path.Segment> thatIter = decendant.iterator(); - while (thisIter.hasNext()) { - Path.Segment thisSeg = thisIter.next(); - Path.Segment thatSeg = thatIter.next(); - if (!thisSeg.equals(thatSeg)) return false; - } - return true; - } + Iterator<Path.Segment> thisIter = this.iterator(); + Iterator<Path.Segment> thatIter = decendant.iterator(); + while (thisIter.hasNext()) { + Path.Segment thisSeg = thisIter.next(); + Path.Segment thatSeg = thatIter.next(); + if (!thisSeg.equals(thatSeg)) return false; + } + return true; + } - /** - * {@inheritDoc} - */ - public boolean isDecendantOf( Path ancestor ) { - if (ancestor == null) return false; - return ancestor.isAncestorOf(this); - } + /** + * {@inheritDoc} + */ + public boolean isDecendantOf( Path ancestor ) { + if (ancestor == null) return false; + return ancestor.isAncestorOf(this); + } - /** - * {@inheritDoc} - */ - public boolean isNormalized() { - return this.normalized; - } + /** + * {@inheritDoc} + */ + public boolean isNormalized() { + return this.normalized; + } - /** - * {@inheritDoc} - */ - public boolean isRoot() { - return this == ROOT || this.segments.isEmpty(); - } + /** + * {@inheritDoc} + */ + public boolean isRoot() { + return this == ROOT || this.segments.isEmpty(); + } - /** - * {@inheritDoc} - */ - public boolean isSame( Path other ) { - return this.compareTo(other) == 0; - } + /** + * {@inheritDoc} + */ + public boolean isSame( Path other ) { + return this.compareTo(other) == 0; + } - /** - * {@inheritDoc} - */ - public Iterator<Segment> iterator() { - return this.segments.iterator(); - } + /** + * {@inheritDoc} + */ + public Iterator<Segment> iterator() { + return this.segments.iterator(); + } - /** - * {@inheritDoc} - */ - public Path relativeTo( Path startingPath ) { - ArgCheck.isNotNull(startingPath, "to"); - if (!this.isAbsolute()) { - String msg = SpiI18n.pathIsNotAbsolute.text(this); - throw new InvalidPathException(msg); - } - if (!startingPath.isAbsolute()) { - String msg = SpiI18n.pathIsNotAbsolute.text(startingPath); - throw new InvalidPathException(msg); - } + /** + * {@inheritDoc} + */ + public Path relativeTo( Path startingPath ) { + ArgCheck.isNotNull(startingPath, "to"); + if (!this.isAbsolute()) { + String msg = SpiI18n.pathIsNotAbsolute.text(this); + throw new InvalidPathException(msg); + } + if (!startingPath.isAbsolute()) { + String msg = SpiI18n.pathIsNotAbsolute.text(startingPath); + throw new InvalidPathException(msg); + } - // Count the number of segments up to the common ancestor (relative path is what remains) ... - int lengthOfCommonAncestor = 0; - Iterator<Segment> thisIter = this.getNormalizedPath().iterator(); - Iterator<Segment> toIter = startingPath.getNormalizedPath().iterator(); - while (thisIter.hasNext() && toIter.hasNext()) { - Segment thisSeg = thisIter.next(); - Segment toSeg = toIter.next(); - if (thisSeg.equals(toSeg)) { - ++lengthOfCommonAncestor; - } else { - break; - } - } - // Create the relative path, starting with parent references to the common ancestor ... - int numberOfParentReferences = startingPath.size() - lengthOfCommonAncestor; - List<Segment> relativeSegments = new ArrayList<Segment>(); - for (int i = 0; i != numberOfParentReferences; ++i) { - relativeSegments.add(Path.PARENT_SEGMENT); - } - // Add the segments of this path from the common ancestor ... - for (int i = lengthOfCommonAncestor; i < this.size(); ++i) { - relativeSegments.add(this.segments.get(i)); - } - if (relativeSegments.isEmpty()) { - relativeSegments.add(Path.SELF_SEGMENT); - } - return new BasicPath(relativeSegments, false); - } + // Count the number of segments up to the common ancestor (relative path is what remains) ... + int lengthOfCommonAncestor = 0; + Iterator<Segment> thisIter = this.getNormalizedPath().iterator(); + Iterator<Segment> toIter = startingPath.getNormalizedPath().iterator(); + while (thisIter.hasNext() && toIter.hasNext()) { + Segment thisSeg = thisIter.next(); + Segment toSeg = toIter.next(); + if (thisSeg.equals(toSeg)) { + ++lengthOfCommonAncestor; + } else { + break; + } + } + // Create the relative path, starting with parent references to the common ancestor ... + int numberOfParentReferences = startingPath.size() - lengthOfCommonAncestor; + List<Segment> relativeSegments = new ArrayList<Segment>(); + for (int i = 0; i != numberOfParentReferences; ++i) { + relativeSegments.add(Path.PARENT_SEGMENT); + } + // Add the segments of this path from the common ancestor ... + for (int i = lengthOfCommonAncestor; i < this.size(); ++i) { + relativeSegments.add(this.segments.get(i)); + } + if (relativeSegments.isEmpty()) { + relativeSegments.add(Path.SELF_SEGMENT); + } + return new BasicPath(relativeSegments, false); + } - /** - * {@inheritDoc} - */ - public Path resolve( Path relativePath ) { - ArgCheck.isNotNull(relativePath, "relative path"); - if (!this.isAbsolute()) { - String msg = SpiI18n.pathIsAlreadyAbsolute.text(this.path); - throw new InvalidPathException(msg); - } - if (relativePath.isAbsolute()) { - String msg = SpiI18n.pathIsNotRelative.text(relativePath); - throw new InvalidPathException(msg); - } - // If the relative path is the self or parent reference ... - relativePath = relativePath.getNormalizedPath(); - if (relativePath.size() == 1) { - Segment onlySegment = relativePath.getSegment(0); - if (onlySegment.isSelfReference()) return this; - if (onlySegment.isParentReference()) return this.getAncestor(); - } - List<Segment> segments = new ArrayList<Segment>(this.size() + relativePath.size()); - segments.addAll(this.segments); - segments.addAll(relativePath.getSegmentsList()); - return new BasicPath(segments, true).getNormalizedPath(); - } + /** + * {@inheritDoc} + */ + public Path resolve( Path relativePath ) { + ArgCheck.isNotNull(relativePath, "relative path"); + if (!this.isAbsolute()) { + String msg = SpiI18n.pathIsAlreadyAbsolute.text(this.path); + throw new InvalidPathException(msg); + } + if (relativePath.isAbsolute()) { + String msg = SpiI18n.pathIsNotRelative.text(relativePath); + throw new InvalidPathException(msg); + } + // If the relative path is the self or parent reference ... + relativePath = relativePath.getNormalizedPath(); + if (relativePath.size() == 1) { + Segment onlySegment = relativePath.getSegment(0); + if (onlySegment.isSelfReference()) return this; + if (onlySegment.isParentReference()) return this.getAncestor(); + } + List<Segment> segments = new ArrayList<Segment>(this.size() + relativePath.size()); + segments.addAll(this.segments); + segments.addAll(relativePath.getSegmentsList()); + return new BasicPath(segments, true).getNormalizedPath(); + } - /** - * {@inheritDoc} - */ - public Path resolveAgainst( Path absolutePath ) { - ArgCheck.isNotNull(absolutePath, "absolute path"); - return absolutePath.resolve(this); - } + /** + * {@inheritDoc} + */ + public Path resolveAgainst( Path absolutePath ) { + ArgCheck.isNotNull(absolutePath, "absolute path"); + return absolutePath.resolve(this); + } - /** - * {@inheritDoc} - */ - public int size() { - return this.segments.size(); - } + /** + * {@inheritDoc} + */ + public int size() { + return this.segments.size(); + } - /** - * {@inheritDoc} - */ - public Path subpath( int beginIndex ) { - if (beginIndex == 0) return this; - int size = size(); - if (beginIndex >= size) { - throw new IndexOutOfBoundsException(SpiI18n.unbleToCreateSubpathBeginIndexGreaterThanOrEqualToSize.text(beginIndex, size)); - } - if (size == 0) return ROOT; - return new BasicPath(this.segments.subList(beginIndex, size), this.isAbsolute()); - } + /** + * {@inheritDoc} + */ + public Path subpath( int beginIndex ) { + if (beginIndex == 0) return this; + int size = size(); + if (beginIndex >= size) { + throw new IndexOutOfBoundsException(SpiI18n.unableToCreateSubpathBeginIndexGreaterThanOrEqualToSize.text(beginIndex, + size)); + } + if (size == 0) return ROOT; + return new BasicPath(this.segments.subList(beginIndex, size), this.isAbsolute()); + } - /** - * {@inheritDoc} - */ - public Path subpath( int beginIndex, int endIndex ) { - int size = size(); - if (beginIndex == 0) { - if (endIndex == 0) return ROOT; - if (endIndex == size) return this; - } - if (beginIndex >= size) { - throw new IndexOutOfBoundsException(SpiI18n.unbleToCreateSubpathBeginIndexGreaterThanOrEqualToSize.text(beginIndex, size)); - } - if (beginIndex > endIndex) { - throw new IndexOutOfBoundsException(SpiI18n.unbleToCreateSubpathBeginIndexGreaterThanOrEqualToEndingIndex.text(beginIndex, endIndex)); - } - // This reuses the same list, so it's pretty efficient ... - return new BasicPath(this.segments.subList(beginIndex, endIndex), this.isAbsolute()); - } + /** + * {@inheritDoc} + */ + public Path subpath( int beginIndex, + int endIndex ) { + int size = size(); + if (beginIndex == 0) { + if (endIndex == 0) return ROOT; + if (endIndex == size) return this; + } + if (beginIndex >= size) { + throw new IndexOutOfBoundsException(SpiI18n.unableToCreateSubpathBeginIndexGreaterThanOrEqualToSize.text(beginIndex, + size)); + } + if (beginIndex > endIndex) { + throw new IndexOutOfBoundsException( + SpiI18n.unableToCreateSubpathBeginIndexGreaterThanOrEqualToEndingIndex.text(beginIndex, + endIndex)); + } + // This reuses the same list, so it's pretty efficient ... + return new BasicPath(this.segments.subList(beginIndex, endIndex), this.isAbsolute()); + } - /** - * {@inheritDoc} - */ - @Override - public int hashCode() { - return this.segments.hashCode(); - } + /** + * {@inheritDoc} + */ + @Override + public int hashCode() { + return this.segments.hashCode(); + } - /** - * {@inheritDoc} - */ - @Override - public boolean equals( Object obj ) { - if (obj == this) return true; - if (obj instanceof Path) { - Path that = (Path)obj; - return this.segments.equals(that.getSegmentsList()); - } - return false; - } + /** + * {@inheritDoc} + */ + @Override + public boolean equals( Object obj ) { + if (obj == this) return true; + if (obj instanceof Path) { + Path that = (Path)obj; + return this.segments.equals(that.getSegmentsList()); + } + return false; + } - /** - * {@inheritDoc} - */ - public int compareTo( Path that ) { - if (this == that) return 0; - Iterator<Segment> thisIter = this.segments.iterator(); - Iterator<Segment> thatIter = that.iterator(); - while (thisIter.hasNext() && thatIter.hasNext()) { - Segment thisSegment = thisIter.next(); - Segment thatSegment = thatIter.next(); - int diff = thisSegment.compareTo(thatSegment); - if (diff != 0) return diff; - } - if (thisIter.hasNext()) return 1; - if (thatIter.hasNext()) return -1; - return 0; - } + /** + * {@inheritDoc} + */ + public int compareTo( Path that ) { + if (this == that) return 0; + Iterator<Segment> thisIter = this.segments.iterator(); + Iterator<Segment> thatIter = that.iterator(); + while (thisIter.hasNext() && thatIter.hasNext()) { + Segment thisSegment = thisIter.next(); + Segment thatSegment = thatIter.next(); + int diff = thisSegment.compareTo(thatSegment); + if (diff != 0) return diff; + } + if (thisIter.hasNext()) return 1; + if (thatIter.hasNext()) return -1; + return 0; + } - /** - * {@inheritDoc} - */ - @Override - public String toString() { - return getString(Path.URL_ENCODER); - } + /** + * {@inheritDoc} + */ + @Override + public String toString() { + return getString(Path.URL_ENCODER); + } } Modified: trunk/dna-spi/src/main/resources/org/jboss/dna/spi/SpiI18n.properties =================================================================== --- trunk/dna-spi/src/main/resources/org/jboss/dna/spi/SpiI18n.properties 2008-06-02 19:56:43 UTC (rev 230) +++ trunk/dna-spi/src/main/resources/org/jboss/dna/spi/SpiI18n.properties 2008-06-02 20:08:01 UTC (rev 231) @@ -19,27 +19,25 @@ # Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA # 02110-1301 USA, or see the FSF site: http://www.fsf.org. # -unableToDiscoverPropertyTypeForNullValue = Unable to discover property type for null value -errorReadingPropertyValueBytes = Error reading bytes -valueJavaTypeNotCompatibleWithPropertyType = Value is instance of Java type "{0}" and is not compatible with the "{1}" property type - -errorConvertingBinaryValueToString = Error while interpretting binary value as a UTF-8 string +closedConnectionMayNotBeUsed = The connection has been closed an may not be used +errorConvertingBinaryValueToString = Error while interpreting binary value as a UTF-8 string errorCreatingValue = Error creating {0} value from {1} "{2}" -unableToCreateValue = Unable to create {0} value from {1} "{2}": undefined type conversion -validPathMayNotContainEmptySegment = The path "{0}" is not valid because it contains an empty segment +errorReadingPropertyValueBytes = Error reading bytes +invalidIndexInSegmentName = Invalid index, "{0}", in segment name: {1} +invalidQualifiedNameString = Unable to parse qualified name from "{0}" +maximumPoolSizeMayNotBeSmallerThanCorePoolSize = The maximum pool size may not be smaller than the core pool size +missingEndBracketInSegmentName = Missing end bracket in segment name: {0} noNamespaceRegisteredForPrefix = There is no namespace registered for the prefix "{0}" - pathAncestorDegreeIsInvalid = Unable to obtain the {1} ancestor for {0} +pathCannotBeNormalized = The path {0} is invalid and cannot be normalized pathIsAlreadyAbsolute = The path {0} is already an absolute path pathIsNotAbsolute = The path {0} is not an absolute path pathIsNotRelative = The path {0} is not a relative path -pathCannotBeNormalized = The path {0} is invalid and cannot be normalized -unbleToCreateSubpathBeginIndexGreaterThanOrEqualToSize = Unable to create subpath: fromIndex({0}) >= size({1}) -unbleToCreateSubpathBeginIndexGreaterThanOrEqualToEndingIndex = Unable to create subpath: fromIndex({0}) >= toIndex({1}) - -invalidQualifiedNameString = Unable to parse qualified name from "{0}" - -maximumPoolSizeMayNotBeSmallerThanCorePoolSize = The maximum pool size may not be smaller than the core pool size repositoryConnectionPoolIsNotRunning = The repository connection pool is not running +unableToCreateSubpathBeginIndexGreaterThanOrEqualToEndingIndex = Unable to create subpath: fromIndex({0}) >= toIndex({1}) +unableToCreateSubpathBeginIndexGreaterThanOrEqualToSize = Unable to create subpath: fromIndex({0}) >= size({1}) +unableToCreateValue = Unable to create {0} value from {1} "{2}": undefined type conversion +unableToDiscoverPropertyTypeForNullValue = Unable to discover property type for null value unableToObtainValidRepositoryAfterAttempts = Unable to obtain a valid repository after {0} attempts -closedConnectionMayNotBeUsed = The connection has been closed an may not be used +validPathMayNotContainEmptySegment = The path "{0}" is not valid because it contains an empty segment +valueJavaTypeNotCompatibleWithPropertyType = Value is instance of Java type "{0}" and is not compatible with the "{1}" property type