Uses of Class
org.modeshape.jcr.cache.NodeKey

Packages that use NodeKey

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.basic	The "basic" Lucene schema has a single index in which all node and property information are indexed into separate fields.
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 NodeKey in org.modeshape.jcr

Fields in org.modeshape.jcr with type parameters of type NodeKey

protected BlockingQueue<NodeKey>

BackupService.BackupActivity.changedDocumentQueue

Methods in org.modeshape.jcr that return NodeKey

protected NodeKey	SystemContent.keyForNamespaceUri(String namespaceUri)
NodeKey	SystemContent.locksKey()
NodeKey	SystemContent.namespacesKey()
NodeKey	SystemContent.nodeTypesKey()
NodeKey	SystemContent.systemKey()
NodeKey	SystemContent.versionHistoryNodeKeyFor(NodeKey versionableNodeKey)
NodeKey	SystemContent.versionStorageKey()

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

protected SchematicEntry	JcrSession.entryForNode(NodeKey nodeKey)
boolean	SystemContent.hasVersionHistory(NodeKey versionableNodeKey)
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	JcrSession.isForeignKey(NodeKey key) Checks if the node given key is foreign by comparing the source key & workspace key against the same keys from this session's root.
protected boolean	JcrSession.nodeExists(NodeKey key) Utility method to determine if the node with the specified key still exists within the transient & persisted state.
protected String	JcrSession.nodeIdentifier(NodeKey key) Returns a string representing a node's identifier, based on whether the node is foreign or not.
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.
NodeKey	SystemContent.versionHistoryNodeKeyFor(NodeKey versionableNodeKey)

Constructor parameters in org.modeshape.jcr with type arguments of type NodeKey

BackupObserver(Queue<NodeKey> changedNodes)

JcrSession.JcrPreSave(SystemContent content, Map<NodeKey,NodeKey> baseVersionKeys, Map<NodeKey,NodeKey> originalVersionKeys)

JcrSession.JcrPreSave(SystemContent content, Map<NodeKey,NodeKey> baseVersionKeys, Map<NodeKey,NodeKey> originalVersionKeys)

JcrSession.JcrPreSave(SystemContent content, Map<NodeKey,NodeKey> baseVersionKeys, Map<NodeKey,NodeKey> originalVersionKeys)

JcrSession.JcrPreSave(SystemContent content, Map<NodeKey,NodeKey> baseVersionKeys, Map<NodeKey,NodeKey> originalVersionKeys)

Uses of NodeKey in org.modeshape.jcr.cache

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

NodeKey	SessionCache.createNodeKey() Create a new node key for the current source and workspace.
NodeKey	SessionCache.createNodeKey(String sourceName, String identifier) Create a new node key for the current source and workspace.
NodeKey	SessionCache.createNodeKeyWithIdentifier(String identifier) Create a new node key for the current source and workspace.
NodeKey	SessionCache.createNodeKeyWithSource(String sourceName) Create a new node key for the current source and workspace.
NodeKey	ChildReference.getKey()
NodeKey	CachedNode.getKey() Get the key for the node.
NodeKey	PathNotFoundException.getLowestExistingKey()
NodeKey	NodeNotFoundException.getNodeKey() Get the key for the node that was not found
NodeKey	LockFailureException.getNodeKey() Get the key for the node that could not be locked
NodeKey	NodeNotFoundInParentException.getParentKey() Get the key for the parent node.
NodeKey	CachedNode.getParentKey(NodeCache cache) Get the node key for this node's primary parent within this workspace.
NodeKey	CachedNode.getParentKeyInAnyWorkspace(NodeCache cache) Get the node key for this node's primary parent in any workspace.
NodeKey	RepositoryCache.getRepositoryMetadataDocumentKey() Get the identifier of the repository's metadata document.
NodeKey	NodeCache.getRootKey() Get the node key for the root node.
NodeKey	RepositoryCache.getSystemKey()
NodeKey	NodeKey.withId(String identifier)
NodeKey	NodeKey.withRandomId()
NodeKey	NodeKey.withRandomIdAndWorkspace(String workspaceKey)
NodeKey	NodeKey.withSourceKeyAndId(String sourceKey, String identifier)
NodeKey	NodeKey.withWorkspaceKey(String workspaceKey)
NodeKey	NodeKey.withWorkspaceKeyAndId(String workspaceKey, String identifier)

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

Map<NodeKey,NodeKey>	MutableCachedNode.deepCopy(SessionCache cache, CachedNode sourceNode, SessionCache sourceCache) Copies into this node all the properties and children (deep copy) from the given source node.
Map<NodeKey,NodeKey>	MutableCachedNode.deepCopy(SessionCache cache, CachedNode sourceNode, SessionCache sourceCache) Copies into this node all the properties and children (deep copy) from the given source node.
protected Set<NodeKey>	AllPathsCache.getAdditionalParentKeys(CachedNode node, NodeCache cache)
Set<NodeKey>	CachedNode.getAdditionalParentKeys(NodeCache cache) Get the keys for all of the nodes (other than the primary parent) under which this node appears.
Iterator<NodeKey>	ChildReferences.getAllKeys() Get the keys for all of the children.
Iterator<NodeKey>	NodeCache.getAllNodeKeys() Get an iterator over all node keys within this cache.
Iterator<NodeKey>	NodeCache.getAllNodeKeysAtAndBelow(NodeKey startingKey) Get an iterator over all keys for the supplied node and all its descendants.
Set<NodeKey>	SessionCache.getChangedNodeKeys() Returns a set with the NodeKeys of the transient nodes from this cache.
Set<NodeKey>	SessionCache.getChangedNodeKeysAtOrBelow(CachedNode node) Returns a set with the NodeKeys of the transient nodes from this cache which are at or below the path of the given node
Set<NodeKey>	MutableCachedNode.getChangedReferrerNodes() Returns a set with all the referencing nodes (nodes which are referring this node) which have changed.
Set<NodeKey>	SessionCache.getNodeKeysAtAndBelow(NodeKey nodeKey) Returns a set with the NodeKeys of the existing nodes (persistent not transient & new) which are at and below the path of the node with the given key.
Set<NodeKey>	ReferentialIntegrityException.getReferrers() Get the set of node keys that contain REFERENCE properties to nodes being deleted, and therefore prevent the removal.
Set<NodeKey>	CachedNode.getReferrers(NodeCache cache, CachedNode.ReferenceType type) Get the keys of the nodes that have JCR REFERENCE and/or WEAK_REFERENCE properties pointing to this node.
Set<NodeKey>	ReferentialIntegrityException.getRemovedNodes() Get the set of keys to the nodes that were removed.
Set<NodeKey>	MutableCachedNode.removedChildren() Returns a set with the keys of the children which have been removed for this node.

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

void	MutableCachedNode.addReferrer(SessionCache cache, NodeKey referrerKey, CachedNode.ReferenceType type) Adds to this node a reference with the given type from the node with the supplied key to this node.
int	NodeKey.compareTo(NodeKey that)
int	ChildReferences.Context.consume(Name name, NodeKey key) Consume the next child with the supplied name and key.
int	ChildReferences.NoContext.consume(Name name, NodeKey key)
int	ChildReferences.NoSnsIndexesContext.consume(Name name, NodeKey key)
int	ChildReferences.SingleNameContext.consume(Name name, NodeKey key)
int	ChildReferences.BasicContext.consume(Name name, NodeKey key)
int	ChildReferences.WithChanges.consume(Name name, NodeKey key)
MutableCachedNode	MutableCachedNode.createChild(SessionCache cache, NodeKey key, Name name, Iterable<Property> properties) Create a new node as a child of this node with the supplied name and properties.
MutableCachedNode	MutableCachedNode.createChild(SessionCache cache, NodeKey key, Name name, Property firstProperty, Property... additionalProperties) Create a new node as a child of this node with the supplied name and properties.
void	SessionCache.destroy(NodeKey key) Destroy the subgraph with the supplied node as the top node in the subgraph.
Iterator<NodeKey>	NodeCache.getAllNodeKeysAtAndBelow(NodeKey startingKey) Get an iterator over all keys for the supplied node and all its descendants.
ChildReference	ChildReferences.getChild(NodeKey key) Look for the child reference that has the node key.
ChildReference	ChildReferences.getChild(NodeKey key, ChildReferences.Context context) Look for the child reference that has the node key.
CachedNode	NodeCache.getNode(NodeKey key) Get the cached representation of the node with the supplied node key.
Set<NodeKey>	SessionCache.getNodeKeysAtAndBelow(NodeKey nodeKey) Returns a set with the NodeKeys of the existing nodes (persistent not transient & new) which are at and below the path of the node with the given key.
boolean	ChildReferences.hasChild(NodeKey key) Determine if this contains a reference to the specified child.
ChildReference	ChildReferences.Changes.inserted(NodeKey key) Get the child reference for the inserted node with the supplied key.
ChildReference	ChildReferences.NoChanges.inserted(NodeKey key)
boolean	SessionCache.isDestroyed(NodeKey key) Return whether the node with the supplied key has been removed using this session but not yet persisted.
boolean	MutableCachedNode.linkChild(SessionCache cache, NodeKey childKey, Name name) Link the existing node with the supplied key to be appended as a child of this node.
void	MutableCachedNode.moveChild(SessionCache cache, NodeKey key, MutableCachedNode newParent, Name newName) Remove the node from being a child of this node and append it as a child of the supplied node.
MutableCachedNode	SessionCache.mutable(NodeKey key) Get a mutable form of the node with the supplied key.
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.
void	MutableCachedNode.removeChild(SessionCache cache, NodeKey key) Remove the node from being a child of this node.
boolean	PathCache.removePath(NodeKey key)
boolean	AllPathsCache.removePath(NodeKey key)
void	MutableCachedNode.removeReferrer(SessionCache cache, NodeKey referrerKey, CachedNode.ReferenceType type) Remove from this node a reference with the given type from the node with the supplied key to this node.
void	MutableCachedNode.renameChild(SessionCache cache, NodeKey key, Name newName) Renames the child node.
Name	ChildReferences.Changes.renamed(NodeKey key) Return the new name for the child node with the supplied key.
Name	ChildReferences.NoChanges.renamed(NodeKey key)
void	MutableCachedNode.reorderChild(SessionCache cache, NodeKey key, NodeKey nextNode) Remove the node from being a child of this node and append it as a child before the supplied node.

Method parameters in org.modeshape.jcr.cache with type arguments of type NodeKey

void	SessionEnvironment.Monitor.recordRemove(String workspace, Iterable<NodeKey> keys) Remove from the index for the given workspace all of the nodes with the supplied keys.
void	SessionCache.save(Set<NodeKey> toBeSaved, SessionCache otherSession, SessionCache.PreSave preSaveOperation) Saves all of this session's changes that were made at or below the specified path.

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

ChildReference(NodeKey key, Name name, int snsIndex)

ChildReference(NodeKey key, Path.Segment segment)

LockFailureException(NodeKey key)

LockFailureException(NodeKey key, String message)

LockFailureException(NodeKey key, String message, Throwable cause)

LockFailureException(NodeKey key, Throwable cause)

NodeNotFoundException(NodeKey key)

NodeNotFoundException(NodeKey key, String message)

NodeNotFoundException(NodeKey key, String message, Throwable cause)

NodeNotFoundException(NodeKey key, Throwable cause)

NodeNotFoundInParentException(NodeKey key, NodeKey parentKey)

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)

Constructor parameters in org.modeshape.jcr.cache with type arguments of type NodeKey

ReferentialIntegrityException(Set<NodeKey> removedNodes, Set<NodeKey> referrers)

ReferentialIntegrityException(Set<NodeKey> removedNodes, Set<NodeKey> referrers)

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

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

NodeKey	AbstractNodeChange.getKey()
NodeKey	NodeMoved.getNewParent() Get the parent under which the node now appears.
NodeKey	NodeMoved.getOldParent() Get the parent under which the node formerly appeared.
NodeKey	NodeSequenced.getOutputNodeKey() Get the key of the top-level node that was output by the sequencer.
NodeKey	NodeReordered.getParent()
NodeKey	NodeRemoved.getParentKey() Get the key for the parent under which the new node was added.
NodeKey	NodeAdded.getParentKey() Get the key for the parent under which the new node was added.

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

Set<NodeKey>	RecordingChanges.changedNodes()
Set<NodeKey>	ChangeSet.changedNodes()

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

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.

Method parameters in org.modeshape.jcr.cache.change with type arguments of type NodeKey

void	RecordingChanges.setChangedNodes(Set<NodeKey> keys)

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

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 NodeKey in org.modeshape.jcr.cache.document

Fields in org.modeshape.jcr.cache.document with type parameters of type NodeKey

protected static Iterator<NodeKey>	ImmutableChildReferences.EMPTY_KEY_ITERATOR
protected Map<NodeKey,NodeKey>	SessionNode.DeepCopy.linkedPlaceholdersToOriginal
protected Map<NodeKey,NodeKey>	SessionNode.DeepCopy.linkedPlaceholdersToOriginal
protected Map<NodeKey,NodeKey>	SessionNode.DeepCopy.sourceToTargetKeys
protected Map<NodeKey,NodeKey>	SessionNode.DeepCopy.sourceToTargetKeys

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

NodeKey	AbstractSessionCache.createNodeKey()
NodeKey	AbstractSessionCache.createNodeKey(String sourceName, String identifier)
NodeKey	AbstractSessionCache.createNodeKeyWithIdentifier(String identifier)
NodeKey	AbstractSessionCache.createNodeKeyWithSource(String sourceName)
protected NodeKey	SessionNode.DeepCopy.createTargetKeyFor(NodeKey sourceKey, NodeKey parentKeyInTarget)
protected NodeKey	SessionNode.DeepClone.createTargetKeyFor(NodeKey sourceKey, NodeKey parentKeyInTarget)
NodeKey	SessionNode.getKey()
NodeKey	LazyCachedNode.getKey()
NodeKey	DocumentTranslator.getParentKey(Document document, String primaryWorkspaceKey, String secondaryWorkspaceKey) Obtain the preferred key for the parent of this node.
NodeKey	SessionNode.getParentKey(NodeCache cache)
NodeKey	LazyCachedNode.getParentKey(NodeCache cache)
NodeKey	SessionNode.getParentKeyInAnyWorkspace(NodeCache cache)
NodeKey	LazyCachedNode.getParentKeyInAnyWorkspace(NodeCache cache)
NodeKey	WorkspaceCache.getRootKey()
NodeKey	AbstractSessionCache.getRootKey()
protected NodeKey	SessionNode.newParent()
NodeKey	NodeCacheIterator.next()

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

Map<NodeKey,NodeKey>	SessionNode.deepCopy(SessionCache cache, CachedNode sourceNode, SessionCache sourceCache)
Map<NodeKey,NodeKey>	SessionNode.deepCopy(SessionCache cache, CachedNode sourceNode, SessionCache sourceCache)
List<NodeKey>	SessionNode.ReferrerChanges.getAddedReferrers(CachedNode.ReferenceType type)
Set<NodeKey>	SessionNode.getAdditionalParentKeys(NodeCache cache)
Set<NodeKey>	LazyCachedNode.getAdditionalParentKeys(NodeCache cache)
Set<NodeKey>	SessionNode.ChangedAdditionalParents.getAdditions()
Iterator<NodeKey>	SessionChildReferences.getAllKeys()
Iterator<NodeKey>	MutableChildReferences.getAllKeys()
Iterator<NodeKey>	ImmutableChildReferences.EmptyChildReferences.getAllKeys()
Iterator<NodeKey>	ImmutableChildReferences.Medium.getAllKeys()
Iterator<NodeKey>	ImmutableChildReferences.Segmented.getAllKeys()
Iterator<NodeKey>	WorkspaceCache.getAllNodeKeys()
Iterator<NodeKey>	AbstractSessionCache.getAllNodeKeys()
Iterator<NodeKey>	WorkspaceCache.getAllNodeKeysAtAndBelow(NodeKey startingKey)
Iterator<NodeKey>	AbstractSessionCache.getAllNodeKeysAtAndBelow(NodeKey startingKey)
Set<NodeKey>	WritableSessionCache.getChangedNodeKeys()
Set<NodeKey>	ReadOnlySessionCache.getChangedNodeKeys()
Set<NodeKey>	WritableSessionCache.getChangedNodeKeysAtOrBelow(CachedNode srcNode)
Set<NodeKey>	ReadOnlySessionCache.getChangedNodeKeysAtOrBelow(CachedNode node)
Set<NodeKey>	SessionNode.getChangedReferrerNodes()
Map<NodeKey,SessionNode.Insertions>	SessionNode.ChangedChildren.getInsertionsByBeforeKey() Get the map of insertions keyed by the 'before' node
Map<NodeKey,Name>	SessionNode.ChangedChildren.getNewNames() Get the names for the new nodes, keyed by their key.
Set<NodeKey>	AbstractSessionCache.getNodeKeysAtAndBelow(NodeKey nodeKey)
Set<NodeKey>	DocumentTranslator.getParentKeys(Document document, String primaryWorkspaceKey, String secondaryWorkspaceKey)
Set<NodeKey>	DocumentTranslator.getReferrers(Document document, CachedNode.ReferenceType type)
Set<NodeKey>	SessionNode.getReferrers(NodeCache cache, CachedNode.ReferenceType type)
Set<NodeKey>	LazyCachedNode.getReferrers(NodeCache cache, CachedNode.ReferenceType type)
Set<NodeKey>	SessionNode.ChangedAdditionalParents.getRemovals()
Set<NodeKey>	SessionNode.ChangedChildren.getRemovals() Get the set of keys for the nodes that were removed from the list of child references.
List<NodeKey>	SessionNode.ReferrerChanges.getRemovedReferrers(CachedNode.ReferenceType type)
Map<NodeKey,NodeKey>	SessionNode.DeepCopy.getSourceToTargetKeys()
Map<NodeKey,NodeKey>	SessionNode.DeepCopy.getSourceToTargetKeys()
Iterator<NodeKey>	ImmutableChildReferences.Segment.keys()
Set<NodeKey>	SessionNode.removedChildren()

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

boolean	SessionNode.ChangedAdditionalParents.add(NodeKey key)
void	SessionNode.addReferrer(SessionCache cache, NodeKey referrerKey, CachedNode.ReferenceType type)
void	SessionNode.ReferrerChanges.addStrongReferrer(NodeKey nodeKey)
void	SessionNode.ReferrerChanges.addWeakReferrer(NodeKey nodeKey)
void	MutableChildReferences.append(NodeKey key, Name name)
void	DocumentTranslator.changeChildren(NodeKey key, EditableDocument document, SessionNode.ChangedChildren changedChildren, ChildReferences appended)
MutableCachedNode	SessionNode.createChild(SessionCache cache, NodeKey key, Name name, Iterable<Property> properties)
MutableCachedNode	SessionNode.createChild(SessionCache cache, NodeKey key, Name name, Property firstProperty, Property... additionalProperties)
protected NodeKey	SessionNode.DeepCopy.createTargetKeyFor(NodeKey sourceKey, NodeKey parentKeyInTarget)
protected NodeKey	SessionNode.DeepClone.createTargetKeyFor(NodeKey sourceKey, NodeKey parentKeyInTarget)
void	WritableSessionCache.destroy(NodeKey key)
void	ReadOnlySessionCache.destroy(NodeKey key)
Iterator<NodeKey>	WorkspaceCache.getAllNodeKeysAtAndBelow(NodeKey startingKey)
Iterator<NodeKey>	AbstractSessionCache.getAllNodeKeysAtAndBelow(NodeKey startingKey)
ChildReference	SessionChildReferences.getChild(NodeKey key)
ChildReference	MutableChildReferences.getChild(NodeKey key)
ChildReference	ImmutableChildReferences.EmptyChildReferences.getChild(NodeKey key)
ChildReference	ImmutableChildReferences.Medium.getChild(NodeKey key)
ChildReference	ImmutableChildReferences.Segmented.getChild(NodeKey key)
ChildReference	SessionChildReferences.getChild(NodeKey key, ChildReferences.Context context)
ChildReference	MutableChildReferences.getChild(NodeKey key, ChildReferences.Context context)
ChildReference	ImmutableChildReferences.EmptyChildReferences.getChild(NodeKey key, ChildReferences.Context context)
ChildReference	ImmutableChildReferences.Medium.getChild(NodeKey key, ChildReferences.Context context)
ChildReference	ImmutableChildReferences.Segmented.getChild(NodeKey key, ChildReferences.Context context)
CachedNode	WritableSessionCache.getNode(NodeKey key)
CachedNode	WorkspaceCache.getNode(NodeKey key)
CachedNode	AbstractSessionCache.getNode(NodeKey key)
Set<NodeKey>	AbstractSessionCache.getNodeKeysAtAndBelow(NodeKey nodeKey)
boolean	SessionChildReferences.hasChild(NodeKey key)
boolean	MutableChildReferences.hasChild(NodeKey key)
boolean	ImmutableChildReferences.EmptyChildReferences.hasChild(NodeKey key)
boolean	ImmutableChildReferences.Medium.hasChild(NodeKey key)
boolean	ImmutableChildReferences.Segmented.hasChild(NodeKey key)
ChildReference	SessionNode.ChangedChildren.inserted(NodeKey key)
ChildReference	SessionNode.InsertedChildReferences.inserted(NodeKey key) Get the child reference for the inserted node with the supplied key.
ChildReferences.ChildInsertions	SessionNode.InsertedChildReferences.insertionsBefore(NodeKey key)
boolean	WritableSessionCache.isDestroyed(NodeKey key)
boolean	ReadOnlySessionCache.isDestroyed(NodeKey key)
boolean	SessionNode.linkChild(SessionCache cache, NodeKey childKey, Name name)
protected String	DocumentTranslator.mergeChildren(NodeKey key, EditableDocument document, EditableArray children, boolean isFirst, String nextBlock) Modify the supplied document (with the given key) to merge in all of the children from the next block.
void	SessionNode.moveChild(SessionCache cache, NodeKey key, MutableCachedNode newParent, Name newName)
SessionNode	WritableSessionCache.mutable(NodeKey key)
SessionNode	ReadOnlySessionCache.mutable(NodeKey key)
abstract SessionNode	AbstractSessionCache.mutable(NodeKey key)
protected void	DocumentTranslator.optimizeChildrenBlocks(NodeKey key, EditableDocument document, int targetCountPerBlock, int tolerance) Note that this method changes the underlying db as well as the given document, so *it must* be called either from a transactional context or it must be followed by a session.save call, otherwise there might be inconsistencies between what a session sees as "persisted" state and the reality.
boolean	SessionNode.ChangedAdditionalParents.remove(NodeKey key)
boolean	SessionNode.ChangedChildren.remove(NodeKey key) Remove the supplied node from this node's list of child references.
boolean	SessionNode.InsertedChildReferences.remove(NodeKey key)
ChildReference	SessionNode.Insertions.remove(NodeKey key)
ChildReference	MutableChildReferences.remove(NodeKey key)
void	SessionNode.removeChild(SessionCache cache, NodeKey key)
protected SessionNode	SessionNode.removeChildFromNode(AbstractSessionCache session, NodeKey key)
void	SessionNode.removeReferrer(SessionCache cache, NodeKey referrerKey, CachedNode.ReferenceType type)
void	SessionNode.ReferrerChanges.removeStrongReferrer(NodeKey nodeKey)
void	SessionNode.ReferrerChanges.removeWeakReferrer(NodeKey nodeKey)
void	SessionNode.renameChild(SessionCache cache, NodeKey key, Name newName)
Name	SessionNode.ChangedChildren.renamed(NodeKey key)
void	SessionNode.ChangedChildren.renameTo(NodeKey key, Name newName) Rename the child reference with the given key.
void	SessionNode.reorderChild(SessionCache cache, NodeKey key, NodeKey nextNode)
void	DocumentTranslator.setKey(EditableDocument document, NodeKey key)
void	DocumentTranslator.setParents(EditableDocument document, NodeKey parent, NodeKey oldParent, SessionNode.ChangedAdditionalParents additionalParents)
protected boolean	DocumentTranslator.splitChildren(NodeKey key, EditableDocument document, EditableArray children, int targetCountPerBlock, int tolerance, boolean isFirst, String nextBlock) Split the children in the given document (with the given key) into two or more blocks, based upon the specified number of desired children per block and a tolerance.

Method parameters in org.modeshape.jcr.cache.document with type arguments of type NodeKey

protected void	WritableSessionCache.clearModifiedState(Iterable<NodeKey> savedNodesInOrder)
protected void	WritableSessionCache.clearState(Iterable<NodeKey> savedNodesInOrder)
protected long	DocumentTranslator.insertChildren(EditableDocument document, Map<NodeKey,SessionNode.Insertions> insertionsByBeforeKey, Set<NodeKey> removals, Map<NodeKey,Name> newNames)
protected long	DocumentTranslator.insertChildren(EditableDocument document, Map<NodeKey,SessionNode.Insertions> insertionsByBeforeKey, Set<NodeKey> removals, Map<NodeKey,Name> newNames)
protected long	DocumentTranslator.insertChildren(EditableDocument document, Map<NodeKey,SessionNode.Insertions> insertionsByBeforeKey, Set<NodeKey> removals, Map<NodeKey,Name> newNames)
protected ChangeSet	WritableSessionCache.persistChanges(Iterable<NodeKey> changedNodesInOrder, SessionEnvironment.Monitor monitor) Persist the changes within an already-established transaction.
void	WritableSessionCache.save(Set<NodeKey> toBeSaved, SessionCache other, SessionCache.PreSave preSaveOperation) This method saves the changes made by both sessions within a single transaction.
void	ReadOnlySessionCache.save(Set<NodeKey> toBeSaved, SessionCache otherSession, SessionCache.PreSave preSaveOperation)

Constructors in org.modeshape.jcr.cache.document with parameters of type NodeKey

LazyCachedNode(NodeKey key)

LazyCachedNode(NodeKey key, Document document)

NodeCacheIterator(NodeCache cache, NodeKey startingNode)

SessionNode(NodeKey key, boolean isNew)

WorkspaceCache(ExecutionContext context, String repositoryKey, String workspaceName, SchematicDb database, long largeValueSize, NodeKey rootKey, ConcurrentMap<NodeKey,CachedNode> cache, ChangeSetListener changeSetListener)

Constructor parameters in org.modeshape.jcr.cache.document with type arguments of type NodeKey

WorkspaceCache(ExecutionContext context, String repositoryKey, String workspaceName, SchematicDb database, long largeValueSize, NodeKey rootKey, ConcurrentMap<NodeKey,CachedNode> cache, ChangeSetListener changeSetListener)

Uses of NodeKey in org.modeshape.jcr.query

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

NodeKey

QueryResults.Location.getKey()

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

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

Method parameters in org.modeshape.jcr.query with type arguments of type NodeKey

void	QueryIndexing.removeFromIndex(String workspace, Iterable<NodeKey> keys, org.hibernate.search.backend.TransactionContext txnCtx)

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

QueryResults.Location(Path path, NodeKey key)

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

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

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

Method parameters in org.modeshape.jcr.query.lucene.basic with type arguments of type NodeKey

void	BasicLuceneSchema.removeFromIndex(String workspace, Iterable<NodeKey> keys, org.hibernate.search.backend.TransactionContext txnCtx)

Uses of NodeKey in org.modeshape.jcr.txn

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

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)

Method parameters in org.modeshape.jcr.txn with type arguments of type NodeKey

void	SynchronizedTransactions.AccumulatingMonitor.recordRemove(String workspace, Iterable<NodeKey> keys)

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

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)

Constructor parameters in org.modeshape.jcr.txn with type arguments of type NodeKey

SynchronizedTransactions.RemoveCall(String workspace, Iterable<NodeKey> keys)

Uses of NodeKey in org.modeshape.jcr.value

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

T	ValueFactory.create(NodeKey value) Create a value from a NodeKey.
T[]	ValueFactory.create(NodeKey[] value) Create an array of values from an array of NodeKey.
Reference[]	ReferenceFactory.create(NodeKey[] value, boolean foreign)
Reference	ReferenceFactory.create(NodeKey value, boolean foreign)

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

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

NodeKey

NodeKeyReference.getNodeKey()

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

UUID	UuidValueFactory.create(NodeKey value)
URI	UriValueFactory.create(NodeKey value)
String	StringValueFactory.create(NodeKey value)
Reference	ReferenceValueFactory.create(NodeKey value)
Path	PathValueFactory.create(NodeKey value)
Object	ObjectValueFactory.create(NodeKey value)
Name	NameValueFactory.create(NodeKey value)
Long	LongValueFactory.create(NodeKey value)
DateTime	JodaDateTimeValueFactory.create(NodeKey value)
Double	DoubleValueFactory.create(NodeKey value)
BigDecimal	DecimalValueFactory.create(NodeKey value)
Boolean	BooleanValueFactory.create(NodeKey value)
T[]	AbstractValueFactory.create(NodeKey[] values)
Reference[]	ReferenceValueFactory.create(NodeKey[] values, boolean foreign)
Reference	ReferenceValueFactory.create(NodeKey value, boolean foreign)

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

NodeKeyReference(NodeKey key, boolean weak, boolean isForeign)

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

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

BinaryValue

BinaryStoreValueFactory.create(NodeKey value)