Uses of Interface
org.modeshape.jcr.value.Path

Packages that use Path

org.modeshape.jcr
org.modeshape.jcr.cache
org.modeshape.jcr.cache.change
org.modeshape.jcr.cache.document
org.modeshape.jcr.query	The Query API provides a mechanism for building and executing queries.
org.modeshape.jcr.query.lucene	The core query engine, which currently uses Lucene for indexing and raw queries, and the Hibernate Search engine (which does not depend on or use Hibernate Core or JPA) for updating and querying the Lucene indexes.
org.modeshape.jcr.query.lucene.basic	The "basic" Lucene schema has a single index in which all node and property information are indexed into separate fields.
org.modeshape.jcr.query.model	The Abstract Query Model is a vocabulary that can be used to construct a language-neutral representation of a query.
org.modeshape.jcr.security	ModeShape JCR repositories have a pluggable authentication and authorization framework.
org.modeshape.jcr.txn
org.modeshape.jcr.value	Nodes in a graph contain properties, and this package defines the interfaces, classes and exceptions for representing and working with properties and their values.
org.modeshape.jcr.value.basic	A set of basic implementations of the various interfaces defined in org.modeshape.jcr.value.
org.modeshape.jcr.value.binary

Uses of Path in org.modeshape.jcr

Methods in org.modeshape.jcr with parameters of type Path

protected MutableCachedNode	SystemContent.initializeVersionStorage(NodeKey versionableNodeKey, NodeKey versionHistoryKey, NodeKey versionKey, Name primaryTypeName, Set<Name> mixinTypeNames, Path versionHistoryPath, NodeKey originalVersionKey, DateTime now) Create and initialize the version history structure for a versionable node with the supplied UUID.
protected String	JcrSession.readable(Path path)
MutableCachedNode	SystemContent.recordNewVersion(CachedNode versionableNode, SessionCache cacheForVersionableNode, Path versionHistoryPath, NodeKey originalVersionKey, Collection<Property> versionableProperties, DateTime now, AtomicReference<MutableCachedNode> frozenNodeOutput) The method efficiently updates the JCR version history and storage with a new version of a node being checked in.

Uses of Path in org.modeshape.jcr.cache

Methods in org.modeshape.jcr.cache that return Path

Path	PathNotFoundException.getLowestExistingPath()
Path	PathCache.getPath(CachedNode node)
Path	CachedNode.getPath(NodeCache cache) Get the path to this node.
Path	CachedNode.getPath(PathCache pathCache) Get the path to this node.
Path	PathNotFoundException.getPathNotFound()

Methods in org.modeshape.jcr.cache that return types with arguments of type Path

Iterable<Path>

AllPathsCache.getPaths(CachedNode node) Get all of the paths through which the specified node is accessible, including all paths based upon the node's parent (which can potentially have multiple paths) and upon the node's additional parents (which each can potentially have multiple paths).

Methods in org.modeshape.jcr.cache with parameters of type Path

boolean	CachedNode.isAtOrBelow(NodeCache cache, Path path) Determine if this node is effectively at or below the supplied path.
void	SessionEnvironment.Monitor.recordAdd(String workspace, NodeKey key, Path path, Name primaryType, Set<Name> mixinTypes, Collection<Property> properties) Add to the index the information about a node.
void	SessionEnvironment.Monitor.recordUpdate(String workspace, NodeKey key, Path path, Name primaryType, Set<Name> mixinTypes, Iterator<Property> properties) Update the index to reflect the new state of the node.

Constructors in org.modeshape.jcr.cache with parameters of type Path

PathNotFoundException(Path pathNotFound, NodeKey keyForLowestExistingAncestor, Path pathForLowestExistingAncestor)

PathNotFoundException(Path pathNotFound, NodeKey keyForLowestExistingAncestor, Path pathForLowestExistingAncestor, String message)

PathNotFoundException(Path pathNotFound, NodeKey keyForLowestExistingAncestor, Path pathForLowestExistingAncestor, String message, Throwable cause)

PathNotFoundException(Path pathNotFound, NodeKey keyForLowestExistingAncestor, Path pathForLowestExistingAncestor, Throwable cause)

Uses of Path in org.modeshape.jcr.cache.change

Fields in org.modeshape.jcr.cache.change declared as Path

protected Path

AbstractNodeChange.path

Methods in org.modeshape.jcr.cache.change that return Path

Path	NodeMoved.getNewPath() Get the new path for the node, if it is known
Path	NodeReordered.getOldPath()
Path	NodeMoved.getOldPath() Get the old path for the node, if it is known
Path	NodeSequenced.getOutputNodePath() Get the path of the top-level node that was output by the sequencer.
Path	AbstractNodeChange.getPath() Get the path to the node involved in the change.
Path	PropertyRemoved.getPathToNode()
Path	PropertyChanged.getPathToNode()
Path	PropertyAdded.getPathToNode()
Path	NodeReordered.getReorderedBeforePath() Gets the path of the node at the "destination" of the reordering.

Methods in org.modeshape.jcr.cache.change with parameters of type Path

void	RecordingChanges.nodeChanged(NodeKey key, Path path)
void	NoOpChanges.nodeChanged(NodeKey key, Path path)
void	Changes.nodeChanged(NodeKey key, Path path) Create an event signifying that something about the node (other than the properties or location) changed.
void	RecordingChanges.nodeCreated(NodeKey key, NodeKey parentKey, Path path, Map<Name,Property> properties)
void	NoOpChanges.nodeCreated(NodeKey key, NodeKey parentKey, Path path, Map<Name,Property> properties)
void	Changes.nodeCreated(NodeKey key, NodeKey parentKey, Path path, Map<Name,Property> properties) Signal that a new node was created.
void	RecordingChanges.nodeMoved(NodeKey key, NodeKey newParent, NodeKey oldParent, Path newPath, Path oldPath)
void	NoOpChanges.nodeMoved(NodeKey key, NodeKey newParent, NodeKey oldParent, Path newPath, Path oldPath)
void	Changes.nodeMoved(NodeKey key, NodeKey newParent, NodeKey oldParent, Path newPath, Path oldPath) Signal that a node was moved from one parent to another, and may have also been renamed.
void	RecordingChanges.nodeRemoved(NodeKey key, NodeKey parentKey, Path path)
void	NoOpChanges.nodeRemoved(NodeKey key, NodeKey parentKey, Path path)
void	Changes.nodeRemoved(NodeKey key, NodeKey parentKey, Path path) Signal that a node was removed.
void	RecordingChanges.nodeRenamed(NodeKey key, Path newPath, Path.Segment oldName)
void	NoOpChanges.nodeRenamed(NodeKey key, Path path, Path.Segment oldName)
void	Changes.nodeRenamed(NodeKey key, Path newPath, Path.Segment oldName) Signal that a node was renamed (but still has the same parent)
void	RecordingChanges.nodeReordered(NodeKey key, NodeKey parent, Path newPath, Path oldPath, Path reorderedBeforePath)
void	NoOpChanges.nodeReordered(NodeKey key, NodeKey parent, Path newPath, Path oldPath, Path reorderedBeforePath)
void	Changes.nodeReordered(NodeKey key, NodeKey parent, Path newPath, Path oldPath, Path reorderedBeforePath) Signal that a node was placed into a new location within the same parent.
void	RecordingChanges.nodeSequenced(NodeKey sequencedNodeKey, Path sequencedNodePath, NodeKey outputNodeKey, Path outputNodePath, String outputPath, String userId, String selectedPath, String sequencerName)
void	NoOpChanges.nodeSequenced(NodeKey sequencedNodeKey, Path sequencedNodePath, NodeKey outputNodeKey, Path outputNodePath, String outputPath, String userId, String selectedPath, String sequencerName)
void	Changes.nodeSequenced(NodeKey sequencedNodeKey, Path sequencedNodePath, NodeKey outputNodeKey, Path outputNodePath, String outputPath, String userId, String selectedPath, String sequencerName) Signal that a node was successfully sequenced.
void	RecordingChanges.nodeSequencingFailure(NodeKey sequencedNodeKey, Path sequencedNodePath, String outputPath, String userId, String selectedPath, String sequencerName, Throwable cause)
void	NoOpChanges.nodeSequencingFailure(NodeKey sequencedNodeKey, Path sequencedNodePath, String outputPath, String userId, String selectedPath, String sequencerName, Throwable cause)
void	Changes.nodeSequencingFailure(NodeKey sequencedNodeKey, Path sequencedNodePath, String outputPath, String userId, String selectedPath, String sequencerName, Throwable cause) Signal that a node was not sequenced successfully.
void	RecordingChanges.propertyAdded(NodeKey key, Path nodePath, Property property)
void	NoOpChanges.propertyAdded(NodeKey key, Path nodePath, Property property)
void	Changes.propertyAdded(NodeKey key, Path nodePath, Property property) Signal that a property was added to a node.
void	RecordingChanges.propertyChanged(NodeKey key, Path nodePath, Property newProperty, Property oldProperty)
void	NoOpChanges.propertyChanged(NodeKey key, Path nodePath, Property newProperty, Property oldProperty)
void	Changes.propertyChanged(NodeKey key, Path nodePath, Property newProperty, Property oldProperty) Signal that a property was changed on a node.
void	RecordingChanges.propertyRemoved(NodeKey key, Path nodePath, Property property)
void	NoOpChanges.propertyRemoved(NodeKey key, Path nodePath, Property property)
void	Changes.propertyRemoved(NodeKey key, Path nodePath, Property property) Signal that a property was removed from a node.

Constructors in org.modeshape.jcr.cache.change with parameters of type Path

AbstractNodeChange(NodeKey key, Path path)

AbstractSequencingChange(NodeKey sequencedNodeKey, Path sequencedNodePath, String outputPath, String userId, String selectedPath, String sequencerName)

NodeAdded(NodeKey key, NodeKey parentKey, Path path, Map<Name,Property> properties)

NodeChanged(NodeKey key, Path path)

NodeMoved(NodeKey key, NodeKey oldParent, NodeKey newParent, Path newPath, Path oldPath)

NodeRemoved(NodeKey key, NodeKey parentKey, Path path)

NodeRenamed(NodeKey key, Path newPath, Path.Segment oldSegment)

NodeReordered(NodeKey key, NodeKey parent, Path newPath, Path oldPath, Path reorderedBeforePath)

NodeSequenced(NodeKey sequencedNodeKey, Path sequencedNodePath, NodeKey outputNodeKey, Path outputNodePath, String outputPath, String userId, String selectedPath, String sequencerName)

NodeSequencingFailure(NodeKey sequencedNodeKey, Path sequencedNodePath, String outputPath, String userId, String selectedPath, String sequencerName, Throwable cause)

PropertyAdded(NodeKey key, Path nodePath, Property property)

PropertyChanged(NodeKey key, Path nodePath, Property newProperty, Property oldProperty)

PropertyRemoved(NodeKey key, Path nodePath, Property property)

Uses of Path in org.modeshape.jcr.cache.document

Fields in org.modeshape.jcr.cache.document declared as Path

protected Path

SessionNode.DeepCopy.startingPathInSource

Methods in org.modeshape.jcr.cache.document that return Path

Path	SessionNode.getPath(NodeCache cache)
Path	LazyCachedNode.getPath(NodeCache cache)
Path	SessionNode.getPath(PathCache pathCache)
Path	LazyCachedNode.getPath(PathCache pathCache)

Methods in org.modeshape.jcr.cache.document with parameters of type Path

boolean	SessionNode.isAtOrBelow(NodeCache cache, Path path)
boolean	LazyCachedNode.isAtOrBelow(NodeCache cache, Path path)

Uses of Path in org.modeshape.jcr.query

Methods in org.modeshape.jcr.query that return Path

Path	QueryResults.Location.getPath()
protected Path	JcrAbstractQuery.pathFor(String path)

Methods in org.modeshape.jcr.query with parameters of type Path

void	QueryIndexing.addToIndex(String workspace, NodeKey key, Path path, Name primaryType, Set<Name> mixinTypes, Collection<Property> properties, NodeTypeSchemata schemata, org.hibernate.search.backend.TransactionContext txnCtx) Add to the index the information about a node.
QueryBuilder.CastAs<QueryBuilder.ConstraintBuilder>	QueryBuilder.RightHandSide.cast(Path literal) Define the right-hand side of a comparison.
QueryBuilder.CastAs<QueryBuilder.ConstraintBuilder>	QueryBuilder.UpperBoundary.cast(Path literal) Define the upper boundary value of a range.
QueryBuilder.CastAs<QueryBuilder.AndBuilder<QueryBuilder.UpperBoundary>>	QueryBuilder.LowerBoundary.cast(Path literal) Define the lower boundary value of a range.
protected Value	JcrQueryResult.QueryResultRowIterator.jcrPath(Path path)
QueryBuilder.ConstraintBuilder	QueryBuilder.RightHandSide.literal(Path literal) Define the right-hand side of a comparison.
QueryBuilder.ConstraintBuilder	QueryBuilder.UpperBoundary.literal(Path literal) Define the upper boundary value of a range.
QueryBuilder.AndBuilder<QueryBuilder.UpperBoundary>	QueryBuilder.LowerBoundary.literal(Path literal) Define the lower boundary value of a range.
void	QueryIndexing.updateIndex(String workspace, NodeKey key, Path path, Name primaryType, Set<Name> mixinTypes, Iterator<Property> properties, NodeTypeSchemata schemata, org.hibernate.search.backend.TransactionContext txnCtx) Update the index to reflect the new state of the node.

Constructors in org.modeshape.jcr.query with parameters of type Path

JcrAbstractQuery(JcrQueryContext context, String statement, String language, Path storedAtPath)
Creates a new JCR Query by specifying the query statement itself, the language in which the query is stated, the QueryCommand representation and, optionally, the node from which the query was loaded.

JcrQuery(JcrQueryContext context, String statement, String language, QueryCommand query, PlanHints hints, Path storedAtPath)
Creates a new JCR Query by specifying the query statement itself, the language in which the query is stated, the QueryCommand representation and, optionally, the node from which the query was loaded.

QueryResults.Location(Path path)

QueryResults.Location(Path path, NodeKey key)

Uses of Path in org.modeshape.jcr.query.lucene

Fields in org.modeshape.jcr.query.lucene with type parameters of type Path

protected static CompareQuery.Evaluator<Path>	ComparePathQuery.PATH_IS_GREATER_THAN
protected static CompareQuery.Evaluator<Path>	ComparePathQuery.PATH_IS_GREATER_THAN_OR_EQUAL_TO
protected static CompareQuery.Evaluator<Path>	ComparePathQuery.PATH_IS_LESS_THAN
protected static CompareQuery.Evaluator<Path>	ComparePathQuery.PATH_IS_LESS_THAN_OR_EQUAL_TO

Methods in org.modeshape.jcr.query.lucene that return Path

protected Path

ComparePathQuery.readFromDocument(org.apache.lucene.index.IndexReader reader, int docId)

Methods in org.modeshape.jcr.query.lucene with parameters of type Path

static ComparePathQuery	ComparePathQuery.createQueryForNodesWithPathGreaterThan(Path constraintPath, String fieldName, ValueFactories factories, CaseOperations.CaseOperation caseOperation) Construct a Query implementation that scores documents such that the node represented by the document has a path that is greater than the supplied constraint path.
static ComparePathQuery	ComparePathQuery.createQueryForNodesWithPathGreaterThanOrEqualTo(Path constraintPath, String fieldName, ValueFactories factories, CaseOperations.CaseOperation caseOperation) Construct a Query implementation that scores documents such that the node represented by the document has a path that is greater than or equal to the supplied constraint path.
static ComparePathQuery	ComparePathQuery.createQueryForNodesWithPathLessThan(Path constraintPath, String fieldName, ValueFactories factories, CaseOperations.CaseOperation caseOperation) Construct a Query implementation that scores documents such that the node represented by the document has a path that is less than the supplied constraint path.
static ComparePathQuery	ComparePathQuery.createQueryForNodesWithPathLessThanOrEqualTo(Path constraintPath, String fieldName, ValueFactories factories, CaseOperations.CaseOperation caseOperation) Construct a Query implementation that scores documents such that the node represented by the document has a path that is less than or equal to the supplied constraint path.
protected abstract org.apache.lucene.search.Query	LuceneQueryFactory.findAllNodesAtOrBelow(Path ancestorPath) Return a query that will find all documents representing nodes at or below the supplied path.
protected abstract org.apache.lucene.search.Query	LuceneQueryFactory.findAllNodesBelow(Path ancestorPath) Return a query that will find all documents representing nodes below the supplied path.
protected abstract org.apache.lucene.search.Query	LuceneQueryFactory.findChildNodes(Path parentPath) Return a query that can be used to find all of the documents that represent nodes that are children of the node at the supplied path.
protected abstract org.apache.lucene.search.Query	LuceneQueryFactory.findNodeAt(Path path) Create a query that can be used to find the one document (or node) that exists at the exact path supplied.

Constructors in org.modeshape.jcr.query.lucene with parameters of type Path

ComparePathQuery(String fieldName, Path constraintPath, ValueFactory<Path> pathFactory, ValueFactory<String> stringFactory, CompareQuery.Evaluator<Path> evaluator, CaseOperations.CaseOperation caseOperation)
Construct a Query implementation that scores nodes according to the supplied comparator.

Constructor parameters in org.modeshape.jcr.query.lucene with type arguments of type Path

ComparePathQuery(String fieldName, Path constraintPath, ValueFactory<Path> pathFactory, ValueFactory<String> stringFactory, CompareQuery.Evaluator<Path> evaluator, CaseOperations.CaseOperation caseOperation)
Construct a Query implementation that scores nodes according to the supplied comparator.

ComparePathQuery(String fieldName, Path constraintPath, ValueFactory<Path> pathFactory, ValueFactory<String> stringFactory, CompareQuery.Evaluator<Path> evaluator, CaseOperations.CaseOperation caseOperation)
Construct a Query implementation that scores nodes according to the supplied comparator.

Uses of Path in org.modeshape.jcr.query.lucene.basic

Methods in org.modeshape.jcr.query.lucene.basic with parameters of type Path

void	BasicLuceneSchema.addToIndex(String workspace, NodeKey key, Path path, Name primaryType, Set<Name> mixinTypes, Collection<Property> properties, NodeTypeSchemata schemata, org.hibernate.search.backend.TransactionContext txnCtx)
protected abstract Object	BasicTupleCollector.PseudoColumnAssignment.computeValue(Path path, float score)
protected Object	BasicTupleCollector.PathColumnAssignment.computeValue(Path path, float score)
protected Object	BasicTupleCollector.NameColumnAssignment.computeValue(Path path, float score)
protected Object	BasicTupleCollector.LocalNameColumnAssignment.computeValue(Path path, float score)
protected Object	BasicTupleCollector.ScoreColumnAssignment.computeValue(Path path, float score)
protected Object	BasicTupleCollector.NodeDepthColumnAssignment.computeValue(Path path, float score)
protected org.apache.lucene.search.Query	BasicLuceneQueryFactory.findAllNodesAtOrBelow(Path ancestorPath)
protected org.apache.lucene.search.Query	BasicLuceneQueryFactory.findAllNodesBelow(Path ancestorPath)
protected org.apache.lucene.search.Query	BasicLuceneQueryFactory.findChildNodes(Path parentPath)
protected org.apache.lucene.search.Query	BasicLuceneQueryFactory.findNodeAt(Path path)
protected NodeInfo	BasicLuceneSchema.nodeInfo(String id, String workspace, Path path, Name primaryType, Set<Name> mixinTypes, Iterator<Property> propertyIterator, NodeTypeSchemata schemata)
protected String	BasicLuceneQueryFactory.pathAsString(Path path)
void	BasicTupleCollector.PseudoColumnAssignment.setValue(Object[] tuple, Path path, float score)
protected String	BasicLuceneSchema.stringFrom(Path path)
void	BasicLuceneSchema.updateIndex(String workspace, NodeKey key, Path path, Name primaryType, Set<Name> mixinTypes, Iterator<Property> properties, NodeTypeSchemata schemata, org.hibernate.search.backend.TransactionContext txnCtx)

Uses of Path in org.modeshape.jcr.query.model

Methods in org.modeshape.jcr.query.model with parameters of type Path

protected Visitors.ReadableVisitor

Visitors.ReadableVisitor.append(Path path)

Constructors in org.modeshape.jcr.query.model with parameters of type Path

QueryObjectModel(JcrQueryContext context, String statement, String language, SelectQuery query, PlanHints hints, Path storedAtPath)
Creates a new JCR Query by specifying the query statement itself, the language in which the query is stated, the QueryCommand representation and, optionally, the node from which the query was loaded.

SetQueryObjectModel(JcrQueryContext context, String statement, String language, SetQuery query, PlanHints hints, Path storedAtPath)
Creates a new JCR Query by specifying the set query statement itself, the language in which the query is stated, the SetQuery representation and, optionally, the node from which the query was loaded.

Uses of Path in org.modeshape.jcr.security

Methods in org.modeshape.jcr.security with parameters of type Path

boolean

AuthorizationProvider.hasPermission(ExecutionContext context, String repositoryName, String repositorySourceName, String workspaceName, Path path, String... actions) Determine if the supplied execution context has permission for all of the named actions in the named workspace.

Uses of Path in org.modeshape.jcr.txn

Methods in org.modeshape.jcr.txn with parameters of type Path

void	SynchronizedTransactions.AccumulatingMonitor.recordAdd(String workspace, NodeKey key, Path path, Name primaryType, Set<Name> mixinTypes, Collection<Property> properties)
void	SynchronizedTransactions.AccumulatingMonitor.recordUpdate(String workspace, NodeKey key, Path path, Name primaryType, Set<Name> mixinTypes, Iterator<Property> properties)

Constructors in org.modeshape.jcr.txn with parameters of type Path

SynchronizedTransactions.AddCall(String workspace, NodeKey key, Path path, Name primaryType, Set<Name> mixinTypes, Collection<Property> properties)

SynchronizedTransactions.UpdateCall(String workspace, NodeKey key, Path path, Name primaryType, Set<Name> mixinTypes, Iterator<Property> properties)

Uses of Path in org.modeshape.jcr.value

Fields in org.modeshape.jcr.value declared as Path

static Path

Path.ROOT_PATH Singleton instance of the root path.

Fields in org.modeshape.jcr.value with type parameters of type Path

static Comparator<Path>

ValueComparators.PATH_COMPARATOR A comparator of path values.

Methods in org.modeshape.jcr.value that return Path

Path	PathFactory.create(Path parentPath, Iterable<Path.Segment> segments) Create a path by appending the supplied names to the parent path.
Path	PathFactory.create(Path parentPath, Name... segmentNames) Create a path by appending the supplied names to the parent path.
Path	PathFactory.create(Path parentPath, Name segmentName, int index) Create a path by appending the supplied names to the parent path.
Path	PathFactory.create(Path parentPath, Path.Segment... segments) Create a path by appending the supplied names to the parent path.
Path	PathFactory.create(Path parentPath, Path childPath) Create a path by appending the supplied relative path to the supplied parent path.
Path	PathFactory.create(Path parentPath, String subpath) Create a path by appending the supplied names to the parent path.
Path	PathFactory.create(Path parentPath, String segmentName, int index) Create a path by appending the supplied names to the parent path.
Path	PathFactory.createAbsolutePath(Iterable<Path.Segment> segments) Create an absolute path with the supplied segments, in order.
Path	PathFactory.createAbsolutePath(Name... segmentNames) Create an absolute path with the supplied segment names, in order.
Path	PathFactory.createAbsolutePath(Path.Segment... segments) Create an absolute path with the supplied segments, in order.
Path	PathFactory.createRelativePath() Create an empty relative path (i.e., equivalent to createRelativePath( SELF_SEGMENT)).
Path	PathFactory.createRelativePath(Iterable<Path.Segment> segments) Create a relative path with the supplied segments, in order.
Path	PathFactory.createRelativePath(Name... segmentNames) Create a relative path with the supplied segment names, in order.
Path	PathFactory.createRelativePath(Path.Segment... segments) Create a relative path with the supplied segments, in order.
Path	PathFactory.createRootPath() Create an absolute root path.
Path	Path.getAncestor(int degree) Return the path to the ancestor of the supplied degree.
Path	Path.getCanonicalPath() Get the canonical form of this path.
Path	Path.getCommonAncestor(Path that) Find the lowest common ancestor of this path and the supplied path.
Path	PathNotFoundException.getLowestAncestorThatDoesExist() Get the lowest (closest) existing ancestor of the non-existant location.
Path	Path.getNormalizedPath() Get a normalized path with as many ".." segments and all "." resolved.
Path	Path.getParent() Return the path to the parent, or this path if it is the root.
Path	Location.getPath() Get the path that (at least in part) defines this location.
Path	Path.relativeTo(Path startingPath) Get a relative path from the supplied path to this path.
Path	Path.relativeToRoot() Obtain a path that is relative to the root node.
Path	Path.resolve(Path relativePath) Get the absolute path by resolving the supplied relative (non-absolute) path against this absolute path.
Path	Path.resolveAgainst(Path absolutePath) Get the absolute path by resolving this relative (non-absolute) path against the supplied absolute path.
Path	Path.subpath(int beginIndex) Return a new path consisting of the segments starting at beginIndex index (inclusive).
Path	Path.subpath(int beginIndex, int endIndex) Return a new path consisting of the segments between the beginIndex index (inclusive) and the endIndex index (exclusive).

Methods in org.modeshape.jcr.value that return types with arguments of type Path

Iterator<Path>

Path.pathsFromRoot() Return an iterator that walks the paths from the root path down to this path.

Methods in org.modeshape.jcr.value with parameters of type Path

Property	PropertyFactory.create(Name name, Path value) Create a single-valued property with the supplied name and Path value.
T	ValueFactory.create(Path value) Create a value from a path.
T[]	ValueFactory.create(Path[] values) Create an array of values from an array of paths.
Path	PathFactory.create(Path parentPath, Iterable<Path.Segment> segments) Create a path by appending the supplied names to the parent path.
Path	PathFactory.create(Path parentPath, Name... segmentNames) Create a path by appending the supplied names to the parent path.
Path	PathFactory.create(Path parentPath, Name segmentName, int index) Create a path by appending the supplied names to the parent path.
Path	PathFactory.create(Path parentPath, Path.Segment... segments) Create a path by appending the supplied names to the parent path.
Path	PathFactory.create(Path parentPath, Path childPath) Create a path by appending the supplied relative path to the supplied parent path.
Path	PathFactory.create(Path parentPath, String subpath) Create a path by appending the supplied names to the parent path.
Path	PathFactory.create(Path parentPath, String segmentName, int index) Create a path by appending the supplied names to the parent path.
Path	Path.getCommonAncestor(Path that) Find the lowest common ancestor of this path and the supplied path.
boolean	Path.hasSameAncestor(Path that) Determine whether this path and the supplied path have the same immediate ancestor.
boolean	Path.isAncestorOf(Path descendant) Determine whether this path is an ancestor of the supplied path.
boolean	Path.isAtOrAbove(Path other) Determine whether this path is the same as to or a ancestor of the supplied path.
boolean	Path.isAtOrBelow(Path other) Determine whether this path is the same as to or a descendant of the supplied path.
boolean	Path.isDescendantOf(Path ancestor) Determine whether this path is an descendant of the supplied path.
boolean	Path.isSameAs(Path other) Determine whether this path represents the same as the supplied path.
Path	Path.relativeTo(Path startingPath) Get a relative path from the supplied path to this path.
Path	Path.resolve(Path relativePath) Get the absolute path by resolving the supplied relative (non-absolute) path against this absolute path.
Path	Path.resolveAgainst(Path absolutePath) Get the absolute path by resolving this relative (non-absolute) path against the supplied absolute path.

Constructors in org.modeshape.jcr.value with parameters of type Path

PathNotFoundException(Location location, Path lowestAncestorThatDoesExist)

PathNotFoundException(Location location, Path lowestAncestorThatDoesExist, String message)

PathNotFoundException(Location location, Path lowestAncestorThatDoesExist, String message, Throwable cause)

PathNotFoundException(Location location, Path lowestAncestorThatDoesExist, Throwable cause)

Uses of Path in org.modeshape.jcr.value.basic

Classes in org.modeshape.jcr.value.basic that implement Path

class	AbstractPath An abstract foundation for different Path implementations.
class	BasicPath A basic implementation of Path.
class	ChildPath Implementation of a Path that has the information for the last segment but that points to another Path for the parent information.
class	IdentifierPath Optimized implementation of Path that serves as a JCR identifier path.
class	RootPath Optimized implementation of Path that serves as the root path.

Fields in org.modeshape.jcr.value.basic declared as Path

static Path	BasicPath.EMPTY_RELATIVE
static Path	RootPath.INSTANCE
static Path	BasicPath.PARENT_PATH
static Path	BasicPath.SELF_PATH
static Path	AbstractPath.SELF_PATH

Methods in org.modeshape.jcr.value.basic that return Path

Path	PathValueFactory.create(BigDecimal value)
Path	PathValueFactory.create(BinaryValue value)
Path	PathValueFactory.create(boolean value)
Path	PathValueFactory.create(byte[] value)
Path	PathValueFactory.create(Calendar value)
Path	PathValueFactory.create(Date value)
Path	PathValueFactory.create(DateTime value)
Path	PathValueFactory.create(double value)
Path	PathValueFactory.create(float value)
Path	PathValueFactory.create(InputStream stream)
Path	PathValueFactory.create(int value)
Path	PathValueFactory.create(long value)
Path	PathValueFactory.create(Name value)
Path	PathValueFactory.create(NodeKey value)
Path	PathValueFactory.create(Path.Segment value)
Path	PathValueFactory.create(Path value)
Path	PathValueFactory.create(Path parentPath, Iterable<Path.Segment> segments)
Path	PathValueFactory.create(Path parentPath, Name... segmentNames)
Path	PathValueFactory.create(Path parentPath, Name segmentName, int index)
Path	PathValueFactory.create(Path parentPath, Path.Segment... segments)
Path	PathValueFactory.create(Path parentPath, Path childPath)
Path	PathValueFactory.create(Path parentPath, String subpath)
Path	PathValueFactory.create(Path parentPath, String segmentName, int index)
Path	PathValueFactory.create(Reference value)
Path	PathValueFactory.create(String value)
Path	PathValueFactory.create(String value, TextDecoder decoder)
Path	PathValueFactory.create(URI value)
Path	PathValueFactory.create(UUID value)
Path	PathValueFactory.createAbsolutePath(Iterable<Path.Segment> segments)
Path	PathValueFactory.createAbsolutePath(Name... segmentNames)
Path	PathValueFactory.createAbsolutePath(Path.Segment... segments)
protected Path[]	PathValueFactory.createEmptyArray(int length)
Path	PathValueFactory.createRelativePath()
Path	PathValueFactory.createRelativePath(Iterable<Path.Segment> segments)
Path	PathValueFactory.createRelativePath(Name... segmentNames)
Path	PathValueFactory.createRelativePath(Path.Segment... segments)
Path	PathValueFactory.createRootPath()
Path	RootPath.getAncestor(int degree)
Path	IdentifierPath.getAncestor(int degree)
Path	ChildPath.getAncestor(int degree)
Path	BasicPath.getAncestor(int degree)
Path	RootPath.getCanonicalPath()
Path	IdentifierPath.getCanonicalPath()
Path	AbstractPath.getCanonicalPath()
Path	RootPath.getCommonAncestor(Path that)
Path	IdentifierPath.getCommonAncestor(Path that)
Path	AbstractPath.getCommonAncestor(Path that)
Path	RootPath.getNormalizedPath()
Path	IdentifierPath.getNormalizedPath()
Path	AbstractPath.getNormalizedPath()
Path	RootPath.getParent()
Path	IdentifierPath.getParent()
Path	ChildPath.getParent()
Path	AbstractPath.getParent()
Path	AbstractPath.relativeTo(Path startingPath)
Path	RootPath.relativeToRoot()
Path	IdentifierPath.relativeToRoot()
Path	AbstractPath.relativeToRoot()
Path	RootPath.resolve(Path relativePath)
Path	IdentifierPath.resolve(Path relativePath)
Path	AbstractPath.resolve(Path relativePath)
Path	AbstractPath.resolveAgainst(Path absolutePath)
Path	RootPath.subpath(int beginIndex)
Path	IdentifierPath.subpath(int beginIndex)
Path	AbstractPath.subpath(int beginIndex)
Path	RootPath.subpath(int beginIndex, int endIndex)
Path	IdentifierPath.subpath(int beginIndex, int endIndex)
Path	ChildPath.subpath(int beginIndex, int endIndex)
Path	AbstractPath.subpath(int beginIndex, int endIndex)

Methods in org.modeshape.jcr.value.basic that return types with arguments of type Path

Iterator<Path>	RootPath.pathsFromRoot()
Iterator<Path>	AbstractPath.pathsFromRoot()

Methods in org.modeshape.jcr.value.basic with parameters of type Path

int	RootPath.compareTo(Path other)
int	IdentifierPath.compareTo(Path other)
int	AbstractPath.compareTo(Path that)
Property	BasicPropertyFactory.create(Name name, Path value)
UUID	UuidValueFactory.create(Path value)
URI	UriValueFactory.create(Path value)
String	StringValueFactory.create(Path value)
Reference	ReferenceValueFactory.create(Path value)
Path	PathValueFactory.create(Path value)
Object	ObjectValueFactory.create(Path value)
Name	NameValueFactory.create(Path value)
Long	LongValueFactory.create(Path value)
DateTime	JodaDateTimeValueFactory.create(Path value)
Double	DoubleValueFactory.create(Path value)
BigDecimal	DecimalValueFactory.create(Path value)
Boolean	BooleanValueFactory.create(Path value)
T[]	AbstractValueFactory.create(Path[] values)
Path	PathValueFactory.create(Path parentPath, Iterable<Path.Segment> segments)
Path	PathValueFactory.create(Path parentPath, Name... segmentNames)
Path	PathValueFactory.create(Path parentPath, Name segmentName, int index)
Path	PathValueFactory.create(Path parentPath, Path.Segment... segments)
Path	PathValueFactory.create(Path parentPath, Path childPath)
Path	PathValueFactory.create(Path parentPath, String subpath)
Path	PathValueFactory.create(Path parentPath, String segmentName, int index)
Path	RootPath.getCommonAncestor(Path that)
Path	IdentifierPath.getCommonAncestor(Path that)
Path	AbstractPath.getCommonAncestor(Path that)
boolean	RootPath.hasSameAncestor(Path that)
boolean	IdentifierPath.hasSameAncestor(Path that)
boolean	ChildPath.hasSameAncestor(Path that)
boolean	AbstractPath.hasSameAncestor(Path that)
boolean	RootPath.isAncestorOf(Path descendant)
boolean	IdentifierPath.isAncestorOf(Path descendant)
boolean	AbstractPath.isAncestorOf(Path descendant)
boolean	RootPath.isAtOrAbove(Path other)
boolean	IdentifierPath.isAtOrAbove(Path other)
boolean	AbstractPath.isAtOrAbove(Path other)
boolean	RootPath.isAtOrBelow(Path other)
boolean	IdentifierPath.isAtOrBelow(Path other)
boolean	ChildPath.isAtOrBelow(Path other)
boolean	AbstractPath.isAtOrBelow(Path other)
boolean	RootPath.isDescendantOf(Path ancestor)
boolean	IdentifierPath.isDescendantOf(Path ancestor)
boolean	ChildPath.isDescendantOf(Path ancestor)
boolean	AbstractPath.isDescendantOf(Path ancestor)
boolean	RootPath.isSameAs(Path other)
boolean	IdentifierPath.isSameAs(Path other)
boolean	AbstractPath.isSameAs(Path other)
Path	AbstractPath.relativeTo(Path startingPath)
Path	RootPath.resolve(Path relativePath)
Path	IdentifierPath.resolve(Path relativePath)
Path	AbstractPath.resolve(Path relativePath)
Path	AbstractPath.resolveAgainst(Path absolutePath)

Constructors in org.modeshape.jcr.value.basic with parameters of type Path

ChildPath(Path parent, Path.Segment child)

Uses of Path in org.modeshape.jcr.value.binary

Methods in org.modeshape.jcr.value.binary with parameters of type Path

BinaryValue

BinaryStoreValueFactory.create(Path value)