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

- Packages that use Path
  Package | Description
  --- | ---
  org.modeshape.jcr |
  org.modeshape.jcr.cache |
  org.modeshape.jcr.cache.change |
  org.modeshape.jcr.cache.document |
  org.modeshape.jcr.federation.spi | This package provides a Service Provider Interface (SPI) for connectors to external systems.
  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 |
  org.modeshape.jcr.xml |

- - ### Uses of Path in org.modeshape.jcr

    Methods in org.modeshape.jcr with parameters of type Path
    Modifier and Type | Method and Description
    --- | ---
    `protected void` | Connectors.BasicPathMappings.`add(Path externalPath, Path internalPath, String workspaceName)`
    `boolean` | AccessControlManagerImpl.`hasPermission(Path absPath, String... actions)`
    `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 boolean` | Connectors.`isReadonlyPath(Path path, JcrSession session)`
    `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.
    `Collection<WorkspaceAndPath>` | Connectors.PathMappings.`resolveExternalPathToInternal(Path externalPath)` Attempt to resolve the supplied external path (from the point of view of a connector) to the internal repository path(s) using the connector's projections at the time this object `was obtained`.
    `Collection<WorkspaceAndPath>` | Connectors.EmptyPathMappings.`resolveExternalPathToInternal(Path externalPath)`
    `Collection<WorkspaceAndPath>` | Connectors.BasicPathMappings.`resolveExternalPathToInternal(Path externalPath)`
    `WorkspaceAndPath` | Connectors.PathMapping.`resolveExternalPathToInternal(Path externalPath, PathFactory pathFactory)` Attempt to resolve the supplied external path to an internal path.

    Constructors in org.modeshape.jcr with parameters of type Path
    Constructor and Description
    `Connectors.PathMapping(Path externalPath, Path internalPath, String workspaceName)`

  - ### Uses of Path in org.modeshape.jcr.cache

    Methods in org.modeshape.jcr.cache that return Path
    Modifier and Type | Method and Description
    --- | ---
    `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
    Modifier and Type | Method and Description
    --- | ---
    `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
    Modifier and Type | Method and Description
    --- | ---
    `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, Iterator<Property> propertiesIterator)` 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
    Constructor and Description
    `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
    Modifier and Type | Field and Description
    --- | ---
    `protected Path` | AbstractNodeChange.`path`

    Methods in org.modeshape.jcr.cache.change that return Path
    Modifier and Type | Method and Description
    --- | ---
    `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` | AbstractPropertyChange.`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
    Modifier and Type | Method and Description
    --- | ---
    `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
    Constructor and Description
    `AbstractNodeChange(NodeKey key, Path path)`
    `AbstractPropertyChange(NodeKey key, Path nodePath, Property property)` Creates a new property change event
    `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
    Modifier and Type | Field and Description
    --- | ---
    `protected Path` | SessionNode.DeepCopy.`startingPathInSource`

    Methods in org.modeshape.jcr.cache.document that return Path
    Modifier and Type | Method and Description
    --- | ---
    `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
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | SessionNode.`isAtOrBelow(NodeCache cache, Path path)`
    `boolean` | LazyCachedNode.`isAtOrBelow(NodeCache cache, Path path)`

  - ### Uses of Path in org.modeshape.jcr.federation.spi

    Methods in org.modeshape.jcr.federation.spi that return Path
    Modifier and Type | Method and Description
    --- | ---
    `protected Path` | Connector.`pathFrom(Path parentPath, String childPath)` Helper method that creates a `Path` object from a parent path and a child path string.
    `protected Path` | Connector.`pathFrom(String path)` Helper method that creates a `Path` object from a string.

    Methods in org.modeshape.jcr.federation.spi with parameters of type Path
    Modifier and Type | Method and Description
    --- | ---
    `protected Path` | Connector.`pathFrom(Path parentPath, String childPath)` Helper method that creates a `Path` object from a parent path and a child path string.

  - ### Uses of Path in org.modeshape.jcr.query

    Methods in org.modeshape.jcr.query that return Path
    Modifier and Type | Method and Description
    --- | ---
    `Path` | QueryResults.Location.`getPath()`
    `protected Path` | JcrAbstractQuery.`pathFor(String path)`

    Methods in org.modeshape.jcr.query with parameters of type Path
    Modifier and Type | Method and Description
    --- | ---
    `void` | QueryIndexing.`addToIndex(String workspace, NodeKey key, Path path, Name primaryType, Set<Name> mixinTypes, Iterator<Property> propertiesIterator, 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
    Constructor and Description
    `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
    Modifier and Type | Field and Description
    --- | ---
    `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
    Modifier and Type | Method and Description
    --- | ---
    `protected Path` | ComparePathQuery.`readFromDocument(org.apache.lucene.index.IndexReader reader, int docId)`

    Methods in org.modeshape.jcr.query.lucene with parameters of type Path
    Modifier and Type | Method and Description
    --- | ---
    `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
    Constructor and Description
    `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
    Constructor and Description
    `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
    Modifier and Type | Method and Description
    --- | ---
    `void` | BasicLuceneSchema.`addToIndex(String workspace, NodeKey key, Path path, Name primaryType, Set<Name> mixinTypes, Iterator<Property> propertiesIterator, 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
    Modifier and Type | Method and Description
    --- | ---
    `protected Visitors.ReadableVisitor` | Visitors.ReadableVisitor.`append(Path path)`

    Constructors in org.modeshape.jcr.query.model with parameters of type Path
    Constructor and Description
    `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
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | AdvancedAuthorizationProvider.`hasPermission(AdvancedAuthorizationProvider.Context context, Path absPath, String... actions)` Determine if the supplied execution context has permission for all of the named actions in the given context.
    `boolean` | AuthorizationProvider.`hasPermission(ExecutionContext context, String repositoryName, String repositorySourceName, String workspaceName, Path absPath, 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
    Modifier and Type | Method and Description
    --- | ---
    `void` | SynchronizedTransactions.SynchronizedMonitor.`recordAdd(String workspace, NodeKey key, Path path, Name primaryType, Set<Name> mixinTypes, Iterator<Property> propertiesIterator)`
    `void` | SynchronizedTransactions.SynchronizedMonitor.`recordUpdate(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
    Modifier and Type | Field and Description
    --- | ---
    `static Path` | Path.`ROOT_PATH` Singleton instance of the root path.

    Fields in org.modeshape.jcr.value with type parameters of type Path
    Modifier and Type | Field and Description
    --- | ---
    `static Comparator<Path>` | ValueComparators.`PATH_COMPARATOR` A comparator of path values.

    Methods in org.modeshape.jcr.value that return Path
    Modifier and Type | Method and Description
    --- | ---
    `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` | WorkspaceAndPath.`getPath()` Get the path.
    `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
    Modifier and Type | Method and Description
    --- | ---
    `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
    Modifier and Type | Method and Description
    --- | ---
    `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.
    `WorkspaceAndPath` | WorkspaceAndPath.`withPath(Path path)` Create a new instance that contains the current workspace name but which uses the supplied path.

    Constructors in org.modeshape.jcr.value with parameters of type Path
    Constructor and Description
    `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)`
    `WorkspaceAndPath(String workspaceName, Path path)` Create a new combination of a path within a named workspace.

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

    Classes in org.modeshape.jcr.value.basic that implement Path
    Modifier and Type | Class and Description
    --- | ---
    `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
    Modifier and Type | Field and Description
    --- | ---
    `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
    Modifier and Type | Method and Description
    --- | ---
    `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)`
    `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
    Modifier and Type | Method and Description
    --- | ---
    `Iterator<Path>` | RootPath.`pathsFromRoot()`
    `Iterator<Path>` | AbstractPath.`pathsFromRoot()`

    Methods in org.modeshape.jcr.value.basic with parameters of type Path
    Modifier and Type | Method and Description
    --- | ---
    `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
    Constructor and Description
    `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
    Modifier and Type | Method and Description
    --- | ---
    `BinaryValue` | BinaryStoreValueFactory.`create(Path value)`

  - ### Uses of Path in org.modeshape.jcr.xml

    Methods in org.modeshape.jcr.xml that return Path
    Modifier and Type | Method and Description
    --- | ---
    `Path` | NodeImportXmlHandler.ImportElement.`getPath()` Returns the path of this import element, which translates to the path of the jcr node.

    Method parameters in org.modeshape.jcr.xml with type arguments of type Path
    Modifier and Type | Method and Description
    --- | ---
    `void` | NodeImportDestination.`submit(TreeMap<Path,NodeImportXmlHandler.ImportElement> parseResults)` Processes the given [nodePath, parseElement] mappings, which represent the results of the xml parsing.

Copyright © 2008-2014 JBoss, a division of Red Hat. All Rights Reserved.