Package | Description |
---|---|
org.modeshape.jcr | |
org.modeshape.jcr.cache | |
org.modeshape.jcr.cache.change | |
org.modeshape.jcr.cache.document | |
org.modeshape.jcr.index.local | |
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 |
This package contains the interfaces for managing index providers and index definitions.
|
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.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 |
Modifier and Type | Method and Description |
---|---|
protected void |
Connectors.BasicPathMappings.add(Path externalPath,
Path internalPath,
String workspaceName) |
void |
NodeTypes.NodeDefinitionSet.determineReasonForMismatch(Name childName,
Name childPrimaryType,
boolean skipProtected,
SiblingCounter siblingCounter,
Name parentPrimaryType,
Set<Name> parentMixinTypes,
Path parentPath,
String workspaceName,
String repositoryName,
ExecutionContext context)
Method that can be called after
NodeTypes.NodeDefinitionSet.findBestDefinitionForChild(Name, Name, boolean, SiblingCounter) returns null
to throw an appropriate exception for why each of the parent's child node definition are not applicable for the
proposed child. |
protected 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.
|
Constructor and Description |
---|
Connectors.PathMapping(Path externalPath,
Path internalPath,
String workspaceName) |
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() |
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). |
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.
|
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) |
Modifier and Type | Field and Description |
---|---|
protected Path |
AbstractNodeChange.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.
|
Modifier and Type | Method and Description |
---|---|
protected void |
ChangeSetAdapter.addNode(String workspaceName,
NodeKey key,
Path path,
Name primaryType,
Set<Name> mixinTypes,
CachedNode.Properties properties,
boolean queryable)
Handle the addition of a node.
|
protected void |
ChangeSetAdapter.changeNode(String workspaceName,
NodeKey key,
Path path,
Name primaryType,
Set<Name> mixinTypes,
boolean queryable)
Handle the change of a node.
|
protected void |
ChangeSetAdapter.moveNode(String workspaceName,
NodeKey key,
Name primaryType,
Set<Name> mixinTypes,
NodeKey oldParent,
NodeKey newParent,
Path newPath,
Path oldPath,
boolean queryable)
Handle the move of a node.
|
void |
RecordingChanges.nodeChanged(NodeKey key,
Path path,
Name primaryType,
Set<Name> mixinTypes,
boolean queryable) |
void |
NoOpChanges.nodeChanged(NodeKey key,
Path path,
Name primaryType,
Set<Name> mixinTypes,
boolean queryable) |
void |
Changes.nodeChanged(NodeKey key,
Path path,
Name primaryType,
Set<Name> mixinTypes,
boolean queryable)
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,
boolean queryable) |
void |
NoOpChanges.nodeCreated(NodeKey key,
NodeKey parentKey,
Path path,
Name primaryType,
Set<Name> mixinTypes,
Map<Name,Property> properties,
boolean queryable) |
void |
Changes.nodeCreated(NodeKey key,
NodeKey parentKey,
Path path,
Name primaryType,
Set<Name> mixinTypes,
Map<Name,Property> properties,
boolean queryable)
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,
boolean queryable) |
void |
NoOpChanges.nodeMoved(NodeKey key,
Name primaryType,
Set<Name> mixinTypes,
NodeKey newParent,
NodeKey oldParent,
Path newPath,
Path oldPath,
boolean queryable) |
void |
Changes.nodeMoved(NodeKey key,
Name primaryType,
Set<Name> mixinTypes,
NodeKey newParent,
NodeKey oldParent,
Path newPath,
Path oldPath,
boolean queryable)
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,
boolean queryable) |
void |
NoOpChanges.nodeRemoved(NodeKey key,
NodeKey parentKey,
Path path,
Name primaryType,
Set<Name> mixinTypes,
boolean queryable) |
void |
Changes.nodeRemoved(NodeKey key,
NodeKey parentKey,
Path path,
Name primaryType,
Set<Name> mixinTypes,
boolean queryable)
Signal that a node was removed.
|
void |
RecordingChanges.nodeRenamed(NodeKey key,
Path newPath,
Path.Segment oldName,
Name primaryType,
Set<Name> mixinTypes,
boolean queryable) |
void |
NoOpChanges.nodeRenamed(NodeKey key,
Path newPath,
Path.Segment oldName,
Name primaryType,
Set<Name> mixinTypes,
boolean queryable) |
void |
Changes.nodeRenamed(NodeKey key,
Path newPath,
Path.Segment oldName,
Name primaryType,
Set<Name> mixinTypes,
boolean queryable)
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,
boolean queryable) |
void |
NoOpChanges.nodeReordered(NodeKey key,
Name primaryType,
Set<Name> mixinTypes,
NodeKey parent,
Path newPath,
Path oldPath,
Path reorderedBeforePath,
boolean queryable) |
void |
Changes.nodeReordered(NodeKey key,
Name primaryType,
Set<Name> mixinTypes,
NodeKey parent,
Path newPath,
Path oldPath,
Path reorderedBeforePath,
boolean queryable)
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,
boolean queryable) |
void |
NoOpChanges.nodeSequenced(NodeKey sequencedNodeKey,
Path sequencedNodePath,
Name sequencedNodePrimaryType,
Set<Name> sequencedNodeMixinTypes,
NodeKey outputNodeKey,
Path outputNodePath,
String outputPath,
String userId,
String selectedPath,
String sequencerName,
boolean queryable) |
void |
Changes.nodeSequenced(NodeKey sequencedNodeKey,
Path sequencedNodePath,
Name sequencedNodePrimaryType,
Set<Name> sequencedNodeMixinTypes,
NodeKey outputNodeKey,
Path outputNodePath,
String outputPath,
String userId,
String selectedPath,
String sequencerName,
boolean queryable)
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,
boolean queryable,
Throwable cause) |
void |
NoOpChanges.nodeSequencingFailure(NodeKey sequencedNodeKey,
Path sequencedNodePath,
Name sequencedNodePrimaryType,
Set<Name> sequencedNodeMixinTypes,
String outputPath,
String userId,
String selectedPath,
String sequencerName,
boolean queryable,
Throwable cause) |
void |
Changes.nodeSequencingFailure(NodeKey sequencedNodeKey,
Path sequencedNodePath,
Name sequencedNodePrimaryType,
Set<Name> sequencedNodeMixinTypes,
String outputPath,
String userId,
String selectedPath,
String sequencerName,
boolean queryable,
Throwable cause)
Signal that a node was not sequenced successfully.
|
void |
RecordingChanges.propertyAdded(NodeKey key,
Name nodePrimaryType,
Set<Name> nodeMixinTypes,
Path nodePath,
Property property,
boolean queryable) |
void |
NoOpChanges.propertyAdded(NodeKey key,
Name nodePrimaryType,
Set<Name> nodeMixinTypes,
Path nodePath,
Property property,
boolean queryable) |
void |
Changes.propertyAdded(NodeKey key,
Name nodePrimaryType,
Set<Name> nodeMixinTypes,
Path nodePath,
Property property,
boolean queryable)
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,
boolean queryable) |
void |
NoOpChanges.propertyChanged(NodeKey key,
Name nodePrimaryType,
Set<Name> nodeMixinTypes,
Path nodePath,
Property newProperty,
Property oldProperty,
boolean queryable) |
void |
Changes.propertyChanged(NodeKey key,
Name nodePrimaryType,
Set<Name> nodeMixinTypes,
Path nodePath,
Property newProperty,
Property oldProperty,
boolean queryable)
Signal that a property was changed on a node.
|
void |
RecordingChanges.propertyRemoved(NodeKey key,
Name nodePrimaryType,
Set<Name> nodeMixinTypes,
Path nodePath,
Property property,
boolean queryable) |
void |
NoOpChanges.propertyRemoved(NodeKey key,
Name nodePrimaryType,
Set<Name> nodeMixinTypes,
Path nodePath,
Property property,
boolean queryable) |
void |
Changes.propertyRemoved(NodeKey key,
Name nodePrimaryType,
Set<Name> nodeMixinTypes,
Path nodePath,
Property property,
boolean queryable)
Signal that a property was removed from a node.
|
protected void |
ChangeSetAdapter.reindexNode(String workspaceName,
NodeKey key,
Path path,
Name primaryType,
Set<Name> mixinTypes,
CachedNode.Properties properties,
boolean queryable)
Handle the reindexing of a node.
|
protected void |
ChangeSetAdapter.removeNode(String workspaceName,
NodeKey key,
NodeKey parentKey,
Path path,
Name primaryType,
Set<Name> mixinTypes,
boolean queryable)
Handle the removal of a node.
|
protected void |
ChangeSetAdapter.renameNode(String workspaceName,
NodeKey key,
Path newPath,
Path.Segment oldSegment,
Name primaryType,
Set<Name> mixinTypes,
boolean queryable)
Handle the renaming of a node.
|
protected void |
ChangeSetAdapter.reorderNode(String workspaceName,
NodeKey key,
Name primaryType,
Set<Name> mixinTypes,
NodeKey parent,
Path newPath,
Path oldPath,
Path reorderedBeforePath,
boolean queryable)
Handle the reordering of a node.
|
protected void |
ChangeSetAdapter.sequenced(String workspaceName,
NodeKey sequencedNodeKey,
Path sequencedNodePath,
Name sequencedNodePrimaryType,
Set<Name> sequencedNodeMixinTypes,
NodeKey outputNodeKey,
Path outputNodePath,
String outputPath,
String userId,
String selectedPath,
String sequencerName,
boolean queryable) |
protected void |
ChangeSetAdapter.sequenceFailure(String workspaceName,
NodeKey sequencedNodeKey,
Path sequencedNodePath,
Name sequencedNodePrimaryType,
Set<Name> sequencedNodeMixinTypes,
String outputPath,
String userId,
String selectedPath,
String sequencerName,
boolean queryable,
Throwable cause) |
Constructor and Description |
---|
AbstractNodeChange(NodeKey key,
Path path,
Name primaryType,
Set<Name> mixinTypes,
boolean queryable) |
AbstractPropertyChange(NodeKey key,
Name nodePrimaryType,
Set<Name> nodeMixinTypes,
Path nodePath,
Property property,
boolean queryable) |
AbstractSequencingChange(NodeKey sequencedNodeKey,
Path sequencedNodePath,
Name sequencedNodePrimaryType,
Set<Name> sequencedNodeMixinTypes,
boolean queryable,
String outputPath,
String userId,
String selectedPath,
String sequencerName) |
NodeAdded(NodeKey key,
NodeKey parentKey,
Path path,
Name primaryType,
Set<Name> mixinTypes,
Map<Name,Property> properties,
boolean queryable) |
NodeChanged(NodeKey key,
Path path,
Name primaryType,
Set<Name> mixinTypes,
boolean queryable) |
NodeMoved(NodeKey key,
Name primaryType,
Set<Name> mixinTypes,
NodeKey oldParent,
NodeKey newParent,
Path newPath,
Path oldPath,
boolean queryable) |
NodeRemoved(NodeKey key,
NodeKey parentKey,
Path path,
Name primaryType,
Set<Name> mixinTypes,
boolean queryable) |
NodeRenamed(NodeKey key,
Path newPath,
Path.Segment oldSegment,
Name primaryType,
Set<Name> mixinTypes,
boolean queryable) |
NodeReordered(NodeKey key,
Name primaryType,
Set<Name> mixinTypes,
NodeKey parent,
Path newPath,
Path oldPath,
Path reorderedBeforePath,
boolean queryable) |
NodeSequenced(NodeKey sequencedNodeKey,
Path sequencedNodePath,
Name sequencedNodePrimaryType,
Set<Name> sequencedNodeMixinTypes,
NodeKey outputNodeKey,
Path outputNodePath,
String outputPath,
String userId,
String selectedPath,
String sequencerName,
boolean queryable) |
NodeSequencingFailure(NodeKey sequencedNodeKey,
Path sequencedNodePath,
Name sequencedNodePrimaryType,
Set<Name> sequencedNodeMixinTypes,
String outputPath,
String userId,
String selectedPath,
String sequencerName,
boolean queryable,
Throwable cause) |
PropertyAdded(NodeKey key,
Name nodePrimaryType,
Set<Name> nodeMixinTypes,
Path nodePath,
Property property,
boolean queryable) |
PropertyChanged(NodeKey key,
Name nodePrimaryType,
Set<Name> nodeMixinTypes,
Path nodePath,
Property newProperty,
Property oldProperty,
boolean queryable) |
PropertyRemoved(NodeKey key,
Name nodePrimaryType,
Set<Name> nodeMixinTypes,
Path nodePath,
Property property,
boolean queryable) |
Modifier and Type | Field and Description |
---|---|
protected Path |
SessionNode.DeepCopy.startingPathInSource |
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) |
Modifier and Type | Method and Description |
---|---|
boolean |
SessionNode.isAtOrBelow(NodeCache cache,
Path path) |
boolean |
LazyCachedNode.isAtOrBelow(NodeCache cache,
Path path) |
Modifier and Type | Method and Description |
---|---|
protected Path |
IndexChangeAdapters.NodePathChangeAdapter.convert(Path path) |
protected Path |
IndexChangeAdapters.NodePathChangeAdapter.convertRoot(Path path) |
Modifier and Type | Method and Description |
---|---|
protected void |
IndexChangeAdapters.PathBasedChangeAdapter.addNode(String workspaceName,
NodeKey key,
Path path,
Name primaryType,
Set<Name> mixinTypes,
CachedNode.Properties properties,
boolean queryable) |
protected void |
IndexChangeAdapters.AbstractPropertyChangeAdapter.addNode(String workspaceName,
NodeKey key,
Path path,
Name primaryType,
Set<Name> mixinTypes,
CachedNode.Properties properties,
boolean queryable) |
protected void |
IndexChangeAdapters.PrimaryTypeChangeAdatper.addNode(String workspaceName,
NodeKey key,
Path path,
Name primaryType,
Set<Name> mixinTypes,
CachedNode.Properties properties,
boolean queryable) |
protected void |
IndexChangeAdapters.MixinTypesChangeAdatper.addNode(String workspaceName,
NodeKey key,
Path path,
Name primaryType,
Set<Name> mixinTypes,
CachedNode.Properties properties,
boolean queryable) |
protected void |
IndexChangeAdapters.NodeTypesChangeAdapter.addNode(String workspaceName,
NodeKey key,
Path path,
Name primaryType,
Set<Name> mixinTypes,
CachedNode.Properties properties,
boolean queryable) |
protected abstract T |
IndexChangeAdapters.PathBasedChangeAdapter.convert(Path path) |
protected Long |
IndexChangeAdapters.NodeDepthChangeAdapter.convert(Path path) |
protected Name |
IndexChangeAdapters.NodeNameChangeAdapter.convert(Path path) |
protected String |
IndexChangeAdapters.NodeLocalNameChangeAdapter.convert(Path path) |
protected Path |
IndexChangeAdapters.NodePathChangeAdapter.convert(Path path) |
protected abstract T |
IndexChangeAdapters.PathBasedChangeAdapter.convertRoot(Path path) |
protected Long |
IndexChangeAdapters.NodeDepthChangeAdapter.convertRoot(Path path) |
protected Name |
IndexChangeAdapters.NodeNameChangeAdapter.convertRoot(Path path) |
protected String |
IndexChangeAdapters.NodeLocalNameChangeAdapter.convertRoot(Path path) |
protected Path |
IndexChangeAdapters.NodePathChangeAdapter.convertRoot(Path path) |
protected void |
IndexChangeAdapters.PathBasedChangeAdapter.moveNode(String workspaceName,
NodeKey key,
Name primaryType,
Set<Name> mixinTypes,
NodeKey oldParent,
NodeKey newParent,
Path newPath,
Path oldPath,
boolean queryable) |
protected void |
IndexChangeAdapters.PathBasedChangeAdapter.reindexNode(String workspaceName,
NodeKey key,
Path path,
Name primaryType,
Set<Name> mixinTypes,
CachedNode.Properties properties,
boolean queryable) |
protected void |
IndexChangeAdapters.AbstractPropertyChangeAdapter.reindexNode(String workspaceName,
NodeKey key,
Path path,
Name primaryType,
Set<Name> mixinTypes,
CachedNode.Properties properties,
boolean queryable) |
protected void |
IndexChangeAdapters.PathBasedChangeAdapter.removeNode(String workspaceName,
NodeKey key,
NodeKey parentKey,
Path path,
Name primaryType,
Set<Name> mixinTypes,
boolean queryable) |
protected void |
IndexChangeAdapters.AbstractPropertyChangeAdapter.removeNode(String workspaceName,
NodeKey key,
NodeKey parentKey,
Path path,
Name primaryType,
Set<Name> mixinTypes,
boolean queryable) |
protected void |
IndexChangeAdapters.NodeTypesChangeAdapter.removeNode(String workspaceName,
NodeKey key,
NodeKey parentKey,
Path path,
Name primaryType,
Set<Name> mixinTypes,
boolean queryable) |
Modifier and Type | Method and Description |
---|---|
static IndexChangeAdapter |
IndexChangeAdapters.forNodePath(ExecutionContext context,
ChangeSetAdapter.NodeTypePredicate matcher,
String workspaceName,
org.modeshape.jcr.index.local.LocalDuplicateIndex<Path> index)
Create an
IndexChangeAdapter implementation that handles the "jcr:path" property. |
Constructor and Description |
---|
IndexChangeAdapters.NodePathChangeAdapter(ExecutionContext context,
ChangeSetAdapter.NodeTypePredicate matcher,
String workspaceName,
org.modeshape.jcr.index.local.LocalDuplicateIndex<Path> index) |
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) |
Modifier and Type | Method and Description |
---|---|
void |
CompositeIndexWriter.add(String workspace,
NodeKey key,
Path path,
Name primaryType,
Set<Name> mixinTypes,
CachedNode.Properties properties) |
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.
|
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. |
Modifier and Type | Method and Description |
---|---|
void |
NoOpQueryIndexWriter.add(String workspace,
NodeKey key,
Path path,
Name primaryType,
Set<Name> mixinTypes,
CachedNode.Properties properties) |
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. |
Modifier and Type | Method and Description |
---|---|
abstract TypeSystem.TypeFactory<Path> |
TypeSystem.getPathFactory()
Get the type factory for path objects.
|
Modifier and Type | Method and Description |
---|---|
protected Visitors.ReadableVisitor |
Visitors.ReadableVisitor.append(Path 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)
|
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.
|
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. |
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. |
Modifier and Type | Method and Description |
---|---|
void |
IndexWriter.add(String workspace,
NodeKey key,
Path path,
Name primaryType,
Set<Name> mixinTypes,
CachedNode.Properties properties)
Add to the index the information about a node.
|
void |
IndexFeedback.scan(String workspaceName,
IndexFeedback.IndexingCallback callback,
Path path)
Signal that a portion of the repository content at/under the given path in the specified workspace should be scanned.
|
Modifier and Type | Method and Description |
---|---|
protected void |
IndexChangeAdapter.index(String workspaceName,
NodeKey key,
Path path,
Name primaryType,
Set<Name> mixinTypes,
CachedNode.Properties properties,
boolean queryable)
Index the specific node.
|
Modifier and Type | Field and Description |
---|---|
static Path |
Path.ROOT_PATH
Singleton instance of the root path.
|
Modifier and Type | Field and Description |
---|---|
static Comparator<Path> |
ValueComparators.PATH_COMPARATOR
A comparator of path values.
|
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). |
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.
|
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.
|
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.
|
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. |
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 |
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) |
Modifier and Type | Method and Description |
---|---|
Iterator<Path> |
RootPath.pathsFromRoot() |
Iterator<Path> |
AbstractPath.pathsFromRoot() |
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) |
Constructor and Description |
---|
ChildPath(Path parent,
Path.Segment child) |
Modifier and Type | Method and Description |
---|---|
BinaryValue |
BinaryStoreValueFactory.create(Path value) |
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.
|
Modifier and Type | Method and Description |
---|---|
void |
NodeImportDestination.submit(LinkedHashMap<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.