/** * Return whether this path has a single segment. This method is equivalent to {@code size() == 1}. * * @return true if this path contains exactly one segment, or false otherwise */ default boolean isSingle() { return size() == 1; }
/** * Return whether this path is the root path with no segments. This method is equivalent to {@code size() == 0}. * * @return true if this path contains exactly one segment, or false otherwise */ default boolean isRoot() { return size() == 0; }
/** * Return whether this path has more than one segment. This method is equivalent to {@code size() > 1}. * * @return true if this path contains exactly one segment, or false otherwise */ default boolean isMultiple() { return size() > 1; }
@Override public int size() { return parent.size() + 1; }
@Override public Path subpath(int length) { if (length > size() || length < 0) throw new IllegalArgumentException("Invalid subpath length: " + length); return length <= parent.size() ? parent.subpath(length) : this; }
@Override public String segment(int index) { if (index >= size() || index < 0) throw new IllegalArgumentException("Invalid segment index: " + index); return index < parent.size() ? parent.segment(index) : segment; }
@Override public boolean equals(Object obj) { if (obj == this) return true; if (obj instanceof Path) { Path that = (Path) obj; if (this.size() != that.size()) return false; return this.lastSegment().get().equals(that.lastSegment().get()); } return false; }
@Override public boolean equals(Object obj) { if (obj == this) return true; if (obj instanceof Path) { Path that = (Path) obj; if (this.size() != that.size()) return false; if (!this.parent.equals(that.parent())) return false; return this.segment.equals(that.lastSegment().get()); } return false; }
@Override public boolean equals(Object obj) { if (obj == this) return true; if (obj instanceof Path) { Path that = (Path) obj; if (this.size() != that.size()) return false; Iterator<String> thisIter = this.iterator(); Iterator<String> thatIter = that.iterator(); while (thisIter.hasNext()) { if (!thisIter.next().equals(thatIter.next())) return false; } return true; } return false; }
@Override public Path append(Path relPath) { if (relPath.isRoot()) return this; if (relPath.isSingle()) return new ChildPath(this, relPath.lastSegment().get()); String[] segments = new String[size() + relPath.size()]; int offset = this.copyInto(segments, 0); copyPathInto(relPath, segments, offset); return new MultiSegmentPath(segments); }
@Override public Path append(Path relPath) { if (relPath.isRoot()) return this; if (relPath.isSingle()) return new ChildPath(this, relPath.lastSegment().get()); String[] segments = new String[size() + relPath.size()]; int offset = this.copyInto(segments, 0); copyPathInto(relPath, segments, offset); return new MultiSegmentPath(segments); }
@Override public Path append(Path relPath) { if (relPath.isRoot()) return this; if (relPath.isSingle()) return new ChildPath(this, relPath.lastSegment().get()); String[] segments = new String[size() + relPath.size() + 1]; int offset = copyInto(segments, 0); copyPathInto(relPath, segments, offset); return new MultiSegmentPath(segments); }
@Test public void shouldParseRootPath() { path = parse("/"); assertThat(path.isRoot()).isTrue(); assertThat(path.isSingle()).isFalse(); assertThat(path.size()).isEqualTo(0); }
@Test public void shouldParseSingleAbsolutePath() { path = parse("/a"); assertThat(path.isRoot()).isFalse(); assertThat(path.isSingle()).isTrue(); assertThat(path.size()).isEqualTo(1); assertThat(path.segment(0)).isEqualTo("a"); }
@Test public void shouldParseSingleRelativePath() { path = parse("a"); assertThat(path.isRoot()).isFalse(); assertThat(path.isSingle()).isTrue(); assertThat(path.size()).isEqualTo(1); assertThat(path.segment(0)).isEqualTo("a"); }
@Test public void shouldParseDoubleRelativePath() { path = parse("a/b"); assertThat(path.isRoot()).isFalse(); assertThat(path.isSingle()).isFalse(); assertThat(path.size()).isEqualTo(2); assertThat(path.segment(0)).isEqualTo("a"); assertThat(path.segment(1)).isEqualTo("b"); }
@Test public void shouldParseDoubleAbsolutePath() { path = parse("/a/b"); assertThat(path.isRoot()).isFalse(); assertThat(path.isSingle()).isFalse(); assertThat(path.size()).isEqualTo(2); assertThat(path.segment(0)).isEqualTo("a"); assertThat(path.segment(1)).isEqualTo("b"); }
@Test public void shouldParseMultiRelativePath() { path = parse("a/b"); assertThat(path.isRoot()).isFalse(); assertThat(path.isSingle()).isFalse(); assertThat(path.size()).isEqualTo(2); assertThat(path.segment(0)).isEqualTo("a"); assertThat(path.segment(1)).isEqualTo("b"); }
@Test public void shouldParseMultiAbsolutePath() { path = parse("/a/b/c/d/e"); assertThat(path.isRoot()).isFalse(); assertThat(path.isSingle()).isFalse(); assertThat(path.size()).isEqualTo(5); assertThat(path.segment(0)).isEqualTo("a"); assertThat(path.segment(1)).isEqualTo("b"); assertThat(path.segment(2)).isEqualTo("c"); assertThat(path.segment(3)).isEqualTo("d"); assertThat(path.segment(4)).isEqualTo("e"); }
/** * Return whether this path has a single segment. This method is equivalent to {@code size() == 1}. * * @return true if this path contains exactly one segment, or false otherwise */ default boolean isSingle() { return size() == 1; }