Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| ModeShape Distribution 3.0.0.Beta3
PREV NEXT | FRAMES NO FRAMES

## 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` | `PathNotFoundException.getPathNotFound()`

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)`

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)`

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| ModeShape Distribution 3.0.0.Beta3
PREV NEXT | FRAMES NO FRAMES

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