## 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.query | The Query API provides a mechanism for building and executing queries.
  org.modeshape.jcr.query.engine | This package contains several fully-functional query engine implementations.
  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.spi.federation | This package provides a Service Provider Interface (SPI) for connectors to external systems.
  org.modeshape.jcr.spi.index.provider | This package contains the Service Provider Interface (SPI) for custom index providers, which are components that encapsulate how ModeShape updates and uses a set of particular indexes.
  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, Name primaryType, Set<Name> mixinTypes)`
    `void` | NoOpChanges.`nodeChanged(NodeKey key, Path path, Name primaryType, Set<Name> mixinTypes)`
    `void` | Changes.`nodeChanged(NodeKey key, Path path, Name primaryType, Set<Name> mixinTypes)` 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, Name primaryType, Set<Name> mixinTypes, Map<Name,Property> properties)`
    `void` | NoOpChanges.`nodeCreated(NodeKey key, NodeKey parentKey, Path path, Name primaryType, Set<Name> mixinTypes, Map<Name,Property> properties)`
    `void` | Changes.`nodeCreated(NodeKey key, NodeKey parentKey, Path path, Name primaryType, Set<Name> mixinTypes, Map<Name,Property> properties)` Signal that a new node was created.
    `void` | RecordingChanges.`nodeMoved(NodeKey key, Name primaryType, Set<Name> mixinTypes, NodeKey newParent, NodeKey oldParent, Path newPath, Path oldPath)`
    `void` | NoOpChanges.`nodeMoved(NodeKey key, Name primaryType, Set<Name> mixinTypes, NodeKey newParent, NodeKey oldParent, Path newPath, Path oldPath)`
    `void` | Changes.`nodeMoved(NodeKey key, Name primaryType, Set<Name> mixinTypes, 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, Name primaryType, Set<Name> mixinTypes)`
    `void` | NoOpChanges.`nodeRemoved(NodeKey key, NodeKey parentKey, Path path, Name primaryType, Set<Name> mixinTypes)`
    `void` | Changes.`nodeRemoved(NodeKey key, NodeKey parentKey, Path path, Name primaryType, Set<Name> mixinTypes)` Signal that a node was removed.
    `void` | RecordingChanges.`nodeRenamed(NodeKey key, Path newPath, Path.Segment oldName, Name primaryType, Set<Name> mixinTypes)`
    `void` | NoOpChanges.`nodeRenamed(NodeKey key, Path path, Path.Segment oldName, Name primaryType, Set<Name> mixinTypes)`
    `void` | Changes.`nodeRenamed(NodeKey key, Path newPath, Path.Segment oldName, Name primaryType, Set<Name> mixinTypes)` Signal that a node was renamed (but still has the same parent)
    `void` | RecordingChanges.`nodeReordered(NodeKey key, Name primaryType, Set<Name> mixinTypes, NodeKey parent, Path newPath, Path oldPath, Path reorderedBeforePath)`
    `void` | NoOpChanges.`nodeReordered(NodeKey key, Name primaryType, Set<Name> mixinTypes, NodeKey parent, Path newPath, Path oldPath, Path reorderedBeforePath)`
    `void` | Changes.`nodeReordered(NodeKey key, Name primaryType, Set<Name> mixinTypes, 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, Name sequencedNodePrimaryType, Set<Name> sequencedNodeMixinTypes, NodeKey outputNodeKey, Path outputNodePath, String outputPath, String userId, String selectedPath, String sequencerName)`
    `void` | NoOpChanges.`nodeSequenced(NodeKey sequencedNodeKey, Path sequencedNodePath, Name sequencedNodePrimaryType, Set<Name> sequencedNodeMixinTypes, NodeKey outputNodeKey, Path outputNodePath, String outputPath, String userId, String selectedPath, String sequencerName)`
    `void` | Changes.`nodeSequenced(NodeKey sequencedNodeKey, Path sequencedNodePath, Name sequencedNodePrimaryType, Set<Name> sequencedNodeMixinTypes, 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, Name sequencedNodePrimaryType, Set<Name> sequencedNodeMixinTypes, String outputPath, String userId, String selectedPath, String sequencerName, Throwable cause)`
    `void` | NoOpChanges.`nodeSequencingFailure(NodeKey sequencedNodeKey, Path sequencedNodePath, Name sequencedNodePrimaryType, Set<Name> sequencedNodeMixinTypes, String outputPath, String userId, String selectedPath, String sequencerName, Throwable cause)`
    `void` | Changes.`nodeSequencingFailure(NodeKey sequencedNodeKey, Path sequencedNodePath, Name sequencedNodePrimaryType, Set<Name> sequencedNodeMixinTypes, String outputPath, String userId, String selectedPath, String sequencerName, Throwable cause)` Signal that a node was not sequenced successfully.
    `void` | RecordingChanges.`propertyAdded(NodeKey key, Name nodePrimaryType, Set<Name> nodeMixinTypes, Path nodePath, Property property)`
    `void` | NoOpChanges.`propertyAdded(NodeKey key, Name nodePrimaryType, Set<Name> nodeMixinTypes, Path nodePath, Property property)`
    `void` | Changes.`propertyAdded(NodeKey key, Name nodePrimaryType, Set<Name> nodeMixinTypes, Path nodePath, Property property)` Signal that a property was added to a node.
    `void` | RecordingChanges.`propertyChanged(NodeKey key, Name nodePrimaryType, Set<Name> nodeMixinTypes, Path nodePath, Property newProperty, Property oldProperty)`
    `void` | NoOpChanges.`propertyChanged(NodeKey key, Name nodePrimaryType, Set<Name> nodeMixinTypes, Path nodePath, Property newProperty, Property oldProperty)`
    `void` | Changes.`propertyChanged(NodeKey key, Name nodePrimaryType, Set<Name> nodeMixinTypes, Path nodePath, Property newProperty, Property oldProperty)` Signal that a property was changed on a node.
    `void` | RecordingChanges.`propertyRemoved(NodeKey key, Name nodePrimaryType, Set<Name> nodeMixinTypes, Path nodePath, Property property)`
    `void` | NoOpChanges.`propertyRemoved(NodeKey key, Name nodePrimaryType, Set<Name> nodeMixinTypes, Path nodePath, Property property)`
    `void` | Changes.`propertyRemoved(NodeKey key, Name nodePrimaryType, Set<Name> nodeMixinTypes, 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, Name primaryType, Set<Name> mixinTypes)`
    `AbstractPropertyChange(NodeKey key, Name nodePrimaryType, Set<Name> nodeMixinTypes, Path nodePath, Property property)`
    `AbstractSequencingChange(NodeKey sequencedNodeKey, Path sequencedNodePath, Name sequencedNodePrimaryType, Set<Name> sequencedNodeMixinTypes, String outputPath, String userId, String selectedPath, String sequencerName)`
    `NodeAdded(NodeKey key, NodeKey parentKey, Path path, Name primaryType, Set<Name> mixinTypes, Map<Name,Property> properties)`
    `NodeChanged(NodeKey key, Path path, Name primaryType, Set<Name> mixinTypes)`
    `NodeMoved(NodeKey key, Name primaryType, Set<Name> mixinTypes, NodeKey oldParent, NodeKey newParent, Path newPath, Path oldPath)`
    `NodeRemoved(NodeKey key, NodeKey parentKey, Path path, Name primaryType, Set<Name> mixinTypes)`
    `NodeRenamed(NodeKey key, Path newPath, Path.Segment oldSegment, Name primaryType, Set<Name> mixinTypes)`
    `NodeReordered(NodeKey key, Name primaryType, Set<Name> mixinTypes, NodeKey parent, Path newPath, Path oldPath, Path reorderedBeforePath)`
    `NodeSequenced(NodeKey sequencedNodeKey, Path sequencedNodePath, Name sequencedNodePrimaryType, Set<Name> sequencedNodeMixinTypes, NodeKey outputNodeKey, Path outputNodePath, String outputPath, String userId, String selectedPath, String sequencerName)`
    `NodeSequencingFailure(NodeKey sequencedNodeKey, Path sequencedNodePath, Name sequencedNodePrimaryType, Set<Name> sequencedNodeMixinTypes, String outputPath, String userId, String selectedPath, String sequencerName, Throwable cause)`
    `PropertyAdded(NodeKey key, Name nodePrimaryType, Set<Name> nodeMixinTypes, Path nodePath, Property property)`
    `PropertyChanged(NodeKey key, Name nodePrimaryType, Set<Name> nodeMixinTypes, Path nodePath, Property newProperty, Property oldProperty)`
    `PropertyRemoved(NodeKey key, Name nodePrimaryType, Set<Name> nodeMixinTypes, 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.query

    Methods in org.modeshape.jcr.query that return Path
    Modifier and Type | Method and Description
    --- | ---
    `Path` | JcrQueryContext.`getPath(CachedNode node)` Get the internal `Path` of the supplied cached node.
    `protected Path` | JcrAbstractQuery.`pathFor(String path)`

    Methods in org.modeshape.jcr.query with parameters of type Path
    Modifier and Type | Method and Description
    --- | ---
    `void` | CompositeIndexWriter.`addToIndex(String workspace, NodeKey key, Path path, Name primaryType, Set<Name> mixinTypes, Iterator<Property> propertiesIterator, NodeTypeSchemata schemata, IndexWriter.IndexingContext txnCtx)`
    `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.
    `static RowExtractors.ExtractFromRow` | RowExtractors.`extractRelativePath(int indexInRow, Path relativePath, NodeCache cache, TypeSystem types)` Create an extractor that extracts the path from the node at the given position in the row and applies the relative 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` | CompositeIndexWriter.`updateIndex(String workspace, NodeKey key, Path path, Name primaryType, Set<Name> mixinTypes, Iterator<Property> properties, NodeTypeSchemata schemata, IndexWriter.IndexingContext txnCtx)`

    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.

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

    Methods in org.modeshape.jcr.query.engine with parameters of type Path
    Modifier and Type | Method and Description
    --- | ---
    `void` | NoOpQueryIndexWriter.`addToIndex(String workspace, NodeKey key, Path path, Name primaryType, Set<Name> mixinTypes, Iterator<Property> propertiesIterator, NodeTypeSchemata schemata, IndexWriter.IndexingContext txnCtx)`
    `NodeSequence` | QuerySources.`childNodes(Path parentPath, float score)` Obtain a `NodeSequence` that returns the (queryable) children of the node at the given path in the workspace, where each child node is assigned the given score.
    `NodeSequence` | QuerySources.`descendantNodes(Path ancestorPath, float score)` Obtain a `NodeSequence` that returns the (queryable) descendants of the node at the given path in the workspace, where each descendant node is assigned the given score.
    `protected CachedNode` | QuerySources.`getNodeAtPath(Path path, NodeCache cache)`
    `protected String` | QuerySources.`getWorkspaceName(Path path)`
    `protected NodeCacheIterator` | QuerySources.`nodes(String workspaceName, Path path)` Return an iterator over all nodes at or below the specified path in the named workspace, using the supplied filter.
    `NodeSequence` | QuerySources.`singleNode(Path path, float score)` Obtain a `NodeSequence` that returns the (queryable) node at the given path in the workspace, where the node is assigned the given score.
    `void` | NoOpQueryIndexWriter.`updateIndex(String workspace, NodeKey key, Path path, Name primaryType, Set<Name> mixinTypes, Iterator<Property> properties, NodeTypeSchemata schemata, IndexWriter.IndexingContext txnCtx)`

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

    Methods in org.modeshape.jcr.query.model that return types with arguments of type Path
    Modifier and Type | Method and Description
    --- | ---
    `abstract TypeSystem.TypeFactory<Path>` | TypeSystem.`getPathFactory()` Get the type factory for path objects.

    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.spi.federation

    Methods in org.modeshape.jcr.spi.federation 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.spi.federation 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.spi.index.provider

    Methods in org.modeshape.jcr.spi.index.provider with parameters of type Path
    Modifier and Type | Method and Description
    --- | ---
    `void` | IndexWriter.`addToIndex(String workspace, NodeKey key, Path path, Name primaryType, Set<Name> mixinTypes, Iterator<Property> propertiesIterator, NodeTypeSchemata schemata, IndexWriter.IndexingContext txnCtx)` Add to the index the information about a node.
    `void` | IndexWriter.`updateIndex(String workspace, NodeKey key, Path path, Name primaryType, Set<Name> mixinTypes, Iterator<Property> properties, NodeTypeSchemata schemata, IndexWriter.IndexingContext txnCtx)` Update the index to reflect the new state of the node.

  - ### 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
    --- | ---
    `TypeSystem.TypeFactory<Path>` | ValueTypeSystem.`getPathFactory()`
    `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
    --- | ---
    `int` | ValueComparators.PathComparator.`compare(Path o1, Path o2)`
    `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)`
    `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.