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

- Packages that use NodeKey
  Package | Description
  --- | ---
  org.modeshape.jcr |
  org.modeshape.jcr.cache |
  org.modeshape.jcr.cache.change |
  org.modeshape.jcr.cache.document |
  org.modeshape.jcr.journal |
  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.spi.index.provider | This package contains the Service Provider Interface (SPI) for custom index providers, which are components that encapsulate how ModeShape updates and uses a set of particular indexes.
  org.modeshape.jcr.txn |
  org.modeshape.jcr.value | Nodes in a graph contain properties, and this package defines the interfaces, classes and exceptions for representing and working with properties and their values.
  org.modeshape.jcr.value.basic | A set of basic implementations of the various interfaces defined in `org.modeshape.jcr.value`.
  org.modeshape.jcr.value.binary |

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

    Fields in org.modeshape.jcr with type parameters of type NodeKey
    Modifier and Type | Field and Description
    --- | ---
    `protected BlockingQueue<NodeKey>` | BackupService.BackupActivity.`changedDocumentQueue`

    Methods in org.modeshape.jcr that return NodeKey
    Modifier and Type | Method and Description
    --- | ---
    `static NodeKey` | JcrSession.`createNodeKeyFromIdentifier(String identifier, NodeKey rootKey)` Determine if the supplied string represents just the `node's identifier` or whether it is a string representation of a NodeKey.
    `NodeKey` | SystemContent.`indexesKey()`
    `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
    Modifier and Type | Method and Description
    --- | ---
    `static NodeKey` | JcrSession.`createNodeKeyFromIdentifier(String identifier, NodeKey rootKey)` Determine if the supplied string represents just the `node's identifier` or whether it is a string representation of a 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.
    `static boolean` | JcrSession.`isForeignKey(NodeKey key, NodeKey rootKey)` 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.
    `static String` | JcrSession.`nodeIdentifier(NodeKey key, NodeKey rootKey)` 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)`

    Method parameters in org.modeshape.jcr with type arguments of type NodeKey
    Modifier and Type | Method and Description
    --- | ---
    `void` | JcrSession.SystemSessionCache.`save(Set<NodeKey> toBeSaved, SessionCache otherSession, SessionCache.PreSave preSaveOperation)`

    Constructor parameters in org.modeshape.jcr with type arguments of type NodeKey
    Constructor and Description
    `BackupObserver(Queue<NodeKey> changedNodes)`
    `JcrSession.JcrPreSave(SystemContent content, Map<NodeKey,NodeKey> baseVersionKeys, Map<NodeKey,NodeKey> originalVersionKeys, long aclChangesCount)`
    `JcrSession.JcrPreSave(SystemContent content, Map<NodeKey,NodeKey> baseVersionKeys, Map<NodeKey,NodeKey> originalVersionKeys, long aclChangesCount)`
    `JcrSession.JcrPreSave(SystemContent content, Map<NodeKey,NodeKey> baseVersionKeys, Map<NodeKey,NodeKey> originalVersionKeys, long aclChangesCount)`
    `JcrSession.JcrPreSave(SystemContent content, Map<NodeKey,NodeKey> baseVersionKeys, Map<NodeKey,NodeKey> originalVersionKeys, long aclChangesCount)`

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

    Fields in org.modeshape.jcr.cache declared as NodeKey
    Modifier and Type | Field and Description
    --- | ---
    `protected NodeKey` | RepositoryCache.`systemMetadataKey`

    Fields in org.modeshape.jcr.cache with type parameters of type NodeKey
    Modifier and Type | Field and Description
    --- | ---
    `static Comparator<NodeKey>` | NodeKey.`COMPARATOR`

    Methods in org.modeshape.jcr.cache that return NodeKey
    Modifier and Type | Method and Description
    --- | ---
    `NodeKey` | SessionCacheWrapper.`createNodeKey()`
    `NodeKey` | SessionCache.`createNodeKey()` Create a new node key for the current source and workspace.
    `NodeKey` | SessionCacheWrapper.`createNodeKey(String sourceName, String identifier)`
    `NodeKey` | SessionCache.`createNodeKey(String sourceName, String identifier)` Create a new node key for the current source and workspace.
    `NodeKey` | SessionCacheWrapper.`createNodeKeyWithIdentifier(String identifier)`
    `NodeKey` | SessionCache.`createNodeKeyWithIdentifier(String identifier)` Create a new node key for the current source and workspace.
    `NodeKey` | SessionCacheWrapper.`createNodeKeyWithSource(String sourceName)`
    `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` | SessionCacheWrapper.`getRootKey()`
    `NodeKey` | NodeCache.`getRootKey()` Get the node key for the root node.
    `NodeKey` | RepositoryCache.`getSystemKey()`
    `NodeKey` | MutableCachedNode.NodeChanges.`newPrimaryParent()` Returns the node key of the new primary parent, in case it has changed.
    `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
    Modifier and Type | Method and Description
    --- | ---
    `Set<NodeKey>` | MutableCachedNode.NodeChanges.`addedParents()` Returns the set of parents that have been added
    `Set<NodeKey>` | MutableCachedNode.NodeChanges.`addedStrongReferrers()` Returns a set of node keys with the strong referrers that have been added.
    `Set<NodeKey>` | MutableCachedNode.NodeChanges.`addedWeakReferrers()` Returns a set of node keys with the weak referrers that have been added.
    `LinkedHashMap<NodeKey,Name>` | MutableCachedNode.NodeChanges.`appendedChildren()` Returns the [childKey, childName] pairs of the children that have been appended (at the end).
    `protected Cache<NodeKey,CachedNode>` | RepositoryCache.`cacheForWorkspace(String name)`
    `Map<NodeKey,LinkedHashMap<NodeKey,Name>>` | MutableCachedNode.NodeChanges.`childrenInsertedBefore()` Returns the [insertBeforeChildKey, [childKey, childName]] structure of the children that been inserted before another existing child.
    `Map<NodeKey,LinkedHashMap<NodeKey,Name>>` | MutableCachedNode.NodeChanges.`childrenInsertedBefore()` Returns the [insertBeforeChildKey, [childKey, childName]] structure of the children that been inserted before another existing child.
    `Map<NodeKey,NodeKey>` | MutableCachedNode.`deepCopy(SessionCache cache, CachedNode sourceNode, SessionCache sourceCache, String systemWorkspaceKey, Connectors connectors)` 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, String systemWorkspaceKey, Connectors connectors)` 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>` | SessionCacheWrapper.`getAllNodeKeys()`
    `Iterator<NodeKey>` | NodeCache.`getAllNodeKeys()` Get an iterator over all node keys within this cache.
    `Iterator<NodeKey>` | SessionCacheWrapper.`getAllNodeKeysAtAndBelow(NodeKey startingKey)`
    `Iterator<NodeKey>` | NodeCache.`getAllNodeKeysAtAndBelow(NodeKey startingKey)` Get an iterator over all keys for the supplied node and all its descendants.
    `Set<NodeKey>` | SessionCacheWrapper.`getChangedNodeKeys()`
    `Set<NodeKey>` | SessionCache.`getChangedNodeKeys()` Returns a set with the `NodeKey`s of the transient nodes from this cache.
    `Set<NodeKey>` | SessionCacheWrapper.`getChangedNodeKeysAtOrBelow(CachedNode node)`
    `Set<NodeKey>` | SessionCache.`getChangedNodeKeysAtOrBelow(CachedNode node)` Returns a set with the `NodeKey`s 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>` | SessionCacheWrapper.`getNodeKeysAtAndBelow(NodeKey nodeKey)`
    `Set<NodeKey>` | SessionCache.`getNodeKeysAtAndBelow(NodeKey nodeKey)` Returns a set with the `NodeKey`s 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()` Deprecated. use `MutableCachedNode.NodeChanges.removedChildren()`
    `Set<NodeKey>` | MutableCachedNode.NodeChanges.`removedChildren()` Returns the set of children that have been removed
    `Set<NodeKey>` | MutableCachedNode.NodeChanges.`removedParents()` Returns the set of parents that have been removed
    `Set<NodeKey>` | MutableCachedNode.NodeChanges.`removedStrongReferrers()` Returns a set of node keys with the strong referrers that have been removed.
    `Set<NodeKey>` | MutableCachedNode.NodeChanges.`removedWeakReferrers()` Returns a set of node keys with the weak referrers that have been removed.
    `Map<NodeKey,Name>` | MutableCachedNode.NodeChanges.`renamedChildren()` Returns the [childKey, childName] pairs of the children that have been renamed, where "childName" represents the new name after the rename.

    Methods in org.modeshape.jcr.cache with parameters of type NodeKey
    Modifier and Type | Method and Description
    --- | ---
    `void` | MutableCachedNode.`addReferrer(SessionCache cache, Property property, 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` | SessionCacheWrapper.`destroy(NodeKey key)`
    `void` | SessionCache.`destroy(NodeKey key)` Destroy the subgraph with the supplied node as the top node in the subgraph.
    `Iterator<NodeKey>` | SessionCacheWrapper.`getAllNodeKeysAtAndBelow(NodeKey startingKey)`
    `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` | SessionCacheWrapper.`getNode(NodeKey key)`
    `CachedNode` | CachedNodeSupplier.`getNode(NodeKey key)` Get the cached representation of the node with the supplied node key.
    `Set<NodeKey>` | SessionCacheWrapper.`getNodeKeysAtAndBelow(NodeKey nodeKey)`
    `Set<NodeKey>` | SessionCache.`getNodeKeysAtAndBelow(NodeKey nodeKey)` Returns a set with the `NodeKey`s 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` | SessionCacheWrapper.`isDestroyed(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` | SessionCacheWrapper.`mutable(NodeKey key)`
    `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, Iterator<Property> propertiesIterator)` Add to the index the information about a node.
    `void` | SessionEnvironment.Monitor.`recordUpdate(String workspace, NodeKey key, Path path, Name primaryType, Set<Name> mixinTypes, Iterator<Property> properties)` Update the index to reflect the new state of the node.
    `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, Property property, 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
    Modifier and Type | Method and Description
    --- | ---
    `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` | SessionCacheWrapper.`save(Set<NodeKey> toBeSaved, SessionCache otherSession, SessionCache.PreSave preSaveOperation)`
    `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
    Constructor and Description
    `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
    Constructor and Description
    `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
    Modifier and Type | Method and Description
    --- | ---
    `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
    Modifier and Type | Method and Description
    --- | ---
    `Set<NodeKey>` | RecordingChanges.`changedNodes()`
    `Set<NodeKey>` | ChangeSet.`changedNodes()` Returns the set of keys for the nodes which has been changed.

    Methods in org.modeshape.jcr.cache.change with parameters of type NodeKey
    Modifier and Type | Method and Description
    --- | ---
    `void` | RecordingChanges.`nodeChanged(NodeKey key, Path path, Name primaryType, Set<Name> mixinTypes)`
    `void` | NoOpChanges.`nodeChanged(NodeKey key, Path path, Name primaryType, Set<Name> mixinTypes)`
    `void` | Changes.`nodeChanged(NodeKey key, Path path, Name primaryType, Set<Name> mixinTypes)` Create an event signifying that something about the node (other than the properties or location) changed.
    `void` | RecordingChanges.`nodeCreated(NodeKey key, NodeKey parentKey, Path path, Name primaryType, Set<Name> mixinTypes, Map<Name,Property> properties)`
    `void` | NoOpChanges.`nodeCreated(NodeKey key, NodeKey parentKey, Path path, Name primaryType, Set<Name> mixinTypes, Map<Name,Property> properties)`
    `void` | Changes.`nodeCreated(NodeKey key, NodeKey parentKey, Path path, Name primaryType, Set<Name> mixinTypes, Map<Name,Property> properties)` Signal that a new node was created.
    `void` | RecordingChanges.`nodeMoved(NodeKey key, Name primaryType, Set<Name> mixinTypes, NodeKey newParent, NodeKey oldParent, Path newPath, Path oldPath)`
    `void` | NoOpChanges.`nodeMoved(NodeKey key, Name primaryType, Set<Name> mixinTypes, NodeKey newParent, NodeKey oldParent, Path newPath, Path oldPath)`
    `void` | Changes.`nodeMoved(NodeKey key, Name primaryType, Set<Name> mixinTypes, NodeKey newParent, NodeKey oldParent, Path newPath, Path oldPath)` Signal that a node was moved from one parent to another, and may have also been renamed.
    `void` | RecordingChanges.`nodeRemoved(NodeKey key, NodeKey parentKey, Path path, Name primaryType, Set<Name> mixinTypes)`
    `void` | NoOpChanges.`nodeRemoved(NodeKey key, NodeKey parentKey, Path path, Name primaryType, Set<Name> mixinTypes)`
    `void` | Changes.`nodeRemoved(NodeKey key, NodeKey parentKey, Path path, Name primaryType, Set<Name> mixinTypes)` Signal that a node was removed.
    `void` | RecordingChanges.`nodeRenamed(NodeKey key, Path newPath, Path.Segment oldName, Name primaryType, Set<Name> mixinTypes)`
    `void` | NoOpChanges.`nodeRenamed(NodeKey key, Path path, Path.Segment oldName, Name primaryType, Set<Name> mixinTypes)`
    `void` | Changes.`nodeRenamed(NodeKey key, Path newPath, Path.Segment oldName, Name primaryType, Set<Name> mixinTypes)` Signal that a node was renamed (but still has the same parent)
    `void` | RecordingChanges.`nodeReordered(NodeKey key, Name primaryType, Set<Name> mixinTypes, NodeKey parent, Path newPath, Path oldPath, Path reorderedBeforePath)`
    `void` | NoOpChanges.`nodeReordered(NodeKey key, Name primaryType, Set<Name> mixinTypes, NodeKey parent, Path newPath, Path oldPath, Path reorderedBeforePath)`
    `void` | Changes.`nodeReordered(NodeKey key, Name primaryType, Set<Name> mixinTypes, NodeKey parent, Path newPath, Path oldPath, Path reorderedBeforePath)` Signal that a node was placed into a new location within the same parent.
    `void` | RecordingChanges.`nodeSequenced(NodeKey sequencedNodeKey, Path sequencedNodePath, Name sequencedNodePrimaryType, Set<Name> sequencedNodeMixinTypes, NodeKey outputNodeKey, Path outputNodePath, String outputPath, String userId, String selectedPath, String sequencerName)`
    `void` | NoOpChanges.`nodeSequenced(NodeKey sequencedNodeKey, Path sequencedNodePath, Name sequencedNodePrimaryType, Set<Name> sequencedNodeMixinTypes, NodeKey outputNodeKey, Path outputNodePath, String outputPath, String userId, String selectedPath, String sequencerName)`
    `void` | Changes.`nodeSequenced(NodeKey sequencedNodeKey, Path sequencedNodePath, Name sequencedNodePrimaryType, Set<Name> sequencedNodeMixinTypes, NodeKey outputNodeKey, Path outputNodePath, String outputPath, String userId, String selectedPath, String sequencerName)` Signal that a node was successfully sequenced.
    `void` | RecordingChanges.`nodeSequencingFailure(NodeKey sequencedNodeKey, Path sequencedNodePath, Name sequencedNodePrimaryType, Set<Name> sequencedNodeMixinTypes, String outputPath, String userId, String selectedPath, String sequencerName, Throwable cause)`
    `void` | NoOpChanges.`nodeSequencingFailure(NodeKey sequencedNodeKey, Path sequencedNodePath, Name sequencedNodePrimaryType, Set<Name> sequencedNodeMixinTypes, String outputPath, String userId, String selectedPath, String sequencerName, Throwable cause)`
    `void` | Changes.`nodeSequencingFailure(NodeKey sequencedNodeKey, Path sequencedNodePath, Name sequencedNodePrimaryType, Set<Name> sequencedNodeMixinTypes, String outputPath, String userId, String selectedPath, String sequencerName, Throwable cause)` Signal that a node was not sequenced successfully.
    `void` | RecordingChanges.`propertyAdded(NodeKey key, Name nodePrimaryType, Set<Name> nodeMixinTypes, Path nodePath, Property property)`
    `void` | NoOpChanges.`propertyAdded(NodeKey key, Name nodePrimaryType, Set<Name> nodeMixinTypes, Path nodePath, Property property)`
    `void` | Changes.`propertyAdded(NodeKey key, Name nodePrimaryType, Set<Name> nodeMixinTypes, Path nodePath, Property property)` Signal that a property was added to a node.
    `void` | RecordingChanges.`propertyChanged(NodeKey key, Name nodePrimaryType, Set<Name> nodeMixinTypes, Path nodePath, Property newProperty, Property oldProperty)`
    `void` | NoOpChanges.`propertyChanged(NodeKey key, Name nodePrimaryType, Set<Name> nodeMixinTypes, Path nodePath, Property newProperty, Property oldProperty)`
    `void` | Changes.`propertyChanged(NodeKey key, Name nodePrimaryType, Set<Name> nodeMixinTypes, Path nodePath, Property newProperty, Property oldProperty)` Signal that a property was changed on a node.
    `void` | RecordingChanges.`propertyRemoved(NodeKey key, Name nodePrimaryType, Set<Name> nodeMixinTypes, Path nodePath, Property property)`
    `void` | NoOpChanges.`propertyRemoved(NodeKey key, Name nodePrimaryType, Set<Name> nodeMixinTypes, Path nodePath, Property property)`
    `void` | Changes.`propertyRemoved(NodeKey key, Name nodePrimaryType, Set<Name> nodeMixinTypes, Path nodePath, Property property)` Signal that a property was removed from a node.

    Method parameters in org.modeshape.jcr.cache.change with type arguments of type NodeKey
    Modifier and Type | Method and Description
    --- | ---
    `void` | RecordingChanges.`setChangedNodes(Set<NodeKey> keys)` Sets the list of node keys involved in this change set.

    Constructors in org.modeshape.jcr.cache.change with parameters of type NodeKey
    Constructor and Description
    `AbstractNodeChange(NodeKey key, Path path, Name primaryType, Set<Name> mixinTypes)`
    `AbstractPropertyChange(NodeKey key, Name nodePrimaryType, Set<Name> nodeMixinTypes, Path nodePath, Property property)`
    `AbstractSequencingChange(NodeKey sequencedNodeKey, Path sequencedNodePath, Name sequencedNodePrimaryType, Set<Name> sequencedNodeMixinTypes, String outputPath, String userId, String selectedPath, String sequencerName)`
    `NodeAdded(NodeKey key, NodeKey parentKey, Path path, Name primaryType, Set<Name> mixinTypes, Map<Name,Property> properties)`
    `NodeChanged(NodeKey key, Path path, Name primaryType, Set<Name> mixinTypes)`
    `NodeMoved(NodeKey key, Name primaryType, Set<Name> mixinTypes, NodeKey oldParent, NodeKey newParent, Path newPath, Path oldPath)`
    `NodeRemoved(NodeKey key, NodeKey parentKey, Path path, Name primaryType, Set<Name> mixinTypes)`
    `NodeRenamed(NodeKey key, Path newPath, Path.Segment oldSegment, Name primaryType, Set<Name> mixinTypes)`
    `NodeReordered(NodeKey key, Name primaryType, Set<Name> mixinTypes, NodeKey parent, Path newPath, Path oldPath, Path reorderedBeforePath)`
    `NodeSequenced(NodeKey sequencedNodeKey, Path sequencedNodePath, Name sequencedNodePrimaryType, Set<Name> sequencedNodeMixinTypes, NodeKey outputNodeKey, Path outputNodePath, String outputPath, String userId, String selectedPath, String sequencerName)`
    `NodeSequencingFailure(NodeKey sequencedNodeKey, Path sequencedNodePath, Name sequencedNodePrimaryType, Set<Name> sequencedNodeMixinTypes, String outputPath, String userId, String selectedPath, String sequencerName, Throwable cause)`
    `PropertyAdded(NodeKey key, Name nodePrimaryType, Set<Name> nodeMixinTypes, Path nodePath, Property property)`
    `PropertyChanged(NodeKey key, Name nodePrimaryType, Set<Name> nodeMixinTypes, Path nodePath, Property newProperty, Property oldProperty)`
    `PropertyRemoved(NodeKey key, Name nodePrimaryType, Set<Name> nodeMixinTypes, Path nodePath, Property property)`

  - ### Uses of NodeKey in org.modeshape.jcr.cache.document

    Fields in org.modeshape.jcr.cache.document with type parameters of type NodeKey
    Modifier and Type | Field and Description
    --- | ---
    `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,Set<Property>>` | SessionNode.DeepCopy.`sourceKeyToReferenceProperties`
    `protected Map<NodeKey,NodeKey>` | SessionNode.DeepCopy.`sourceToTargetKeys`
    `protected Map<NodeKey,NodeKey>` | SessionNode.DeepCopy.`sourceToTargetKeys`

    Methods in org.modeshape.jcr.cache.document that return NodeKey
    Modifier and Type | Method and Description
    --- | ---
    `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, String preferredKey)`
    `protected NodeKey` | SessionNode.DeepClone.`createTargetKeyFor(NodeKey sourceKey, NodeKey parentKeyInTarget, String preferredKey)`
    `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
    Modifier and Type | Method and Description
    --- | ---
    `Map<NodeKey,NodeKey>` | SessionNode.`deepCopy(SessionCache cache, CachedNode sourceNode, SessionCache sourceCache, String systemWorkspaceKey, Connectors connectors)`
    `Map<NodeKey,NodeKey>` | SessionNode.`deepCopy(SessionCache cache, CachedNode sourceNode, SessionCache sourceCache, String systemWorkspaceKey, Connectors connectors)`
    `List<NodeKey>` | SessionNode.ReferrerChanges.`getAddedReferrers(CachedNode.ReferenceType type)`
    `Set<NodeKey>` | DocumentTranslator.`getAdditionalParentKeys(Document document)`
    `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>` | ImmutableChildReferences.FederatedReferences.`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.`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
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | SessionNode.ChangedAdditionalParents.`add(NodeKey key)`
    `void` | SessionNode.`addReferrer(SessionCache cache, Property property, NodeKey referrerKey, CachedNode.ReferenceType type)`
    `void` | SessionNode.ReferrerChanges.`addStrongReferrer(Property property, NodeKey nodeKey)`
    `void` | SessionNode.ReferrerChanges.`addWeakReferrer(Property property, NodeKey nodeKey)`
    `void` | MutableChildReferences.`append(NodeKey key, Name name)`
    `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, String preferredKey)`
    `protected NodeKey` | SessionNode.DeepClone.`createTargetKeyFor(NodeKey sourceKey, NodeKey parentKeyInTarget, String preferredKey)`
    `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` | ImmutableChildReferences.FederatedReferences.`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)`
    `ChildReference` | ImmutableChildReferences.FederatedReferences.`getChild(NodeKey key, ChildReferences.Context context)`
    `ChildReference` | WorkspaceCache.`getChildReference(NodeKey parentKey, NodeKey childKey)`
    `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)`
    `boolean` | ImmutableChildReferences.FederatedReferences.`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` | DocumentOptimizer.`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)`
    `boolean` | DocumentOptimizer.`optimizeChildrenBlocks(NodeKey key, EditableDocument document, int targetCountPerBlock, int tolerance)` Optimize the children in the supplied node document 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 childKey)` Remove the child from this parent node.
    `void` | SessionNode.`removeReferrer(SessionCache cache, Property property, NodeKey referrerKey, CachedNode.ReferenceType type)`
    `void` | SessionNode.ReferrerChanges.`removeStrongReferrer(Property property, NodeKey nodeKey)`
    `void` | SessionNode.ReferrerChanges.`removeWeakReferrer(Property property, 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)`
    `protected void` | SessionNode.`replaceParentWithAdditionalParent(NodeCache cache, NodeKey oldParent, NodeKey existingAdditionalParent)`
    `void` | DocumentTranslator.`setKey(EditableDocument document, NodeKey key)`
    `void` | DocumentTranslator.`setParents(EditableDocument document, NodeKey parent, NodeKey oldParent, SessionNode.ChangedAdditionalParents additionalParents)`
    `protected boolean` | SessionNode.DeepCopy.`shouldProcessSourceKey(NodeKey sourceKey)`
    `protected boolean` | DocumentOptimizer.`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
    Modifier and Type | Method and Description
    --- | ---
    `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 void` | WritableSessionCache.`logChangesBeingSaved(Iterable<NodeKey> firstNodesInOrder, Map<NodeKey,SessionNode> firstNodes, Iterable<NodeKey> secondNodesInOrder, Map<NodeKey,SessionNode> secondNodes)`
    `protected void` | WritableSessionCache.`logChangesBeingSaved(Iterable<NodeKey> firstNodesInOrder, Map<NodeKey,SessionNode> firstNodes, Iterable<NodeKey> secondNodesInOrder, Map<NodeKey,SessionNode> secondNodes)`
    `protected void` | WritableSessionCache.`logChangesBeingSaved(Iterable<NodeKey> firstNodesInOrder, Map<NodeKey,SessionNode> firstNodes, Iterable<NodeKey> secondNodesInOrder, Map<NodeKey,SessionNode> secondNodes)`
    `protected void` | WritableSessionCache.`logChangesBeingSaved(Iterable<NodeKey> firstNodesInOrder, Map<NodeKey,SessionNode> firstNodes, Iterable<NodeKey> secondNodesInOrder, Map<NodeKey,SessionNode> secondNodes)`
    `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
    Constructor and Description
    `LazyCachedNode(NodeKey key, Document document)`
    `NodeCacheIterator(NodeCache cache, NodeKey startingNode)` Create a new iterator over the nodes in the supplied node cache that are at or below the supplied starting node.
    `NodeCacheIterator(NodeCache cache, NodeKey startingNode, NodeCacheIterator.NodeFilter filter)` Create a new iterator over the nodes in the supplied node cache that are at or below the supplied starting node.
    `SessionNode(NodeKey key, boolean isNew)`
    `WorkspaceCache(ExecutionContext context, String repositoryKey, String workspaceName, DocumentStore documentStore, DocumentTranslator translator, NodeKey rootKey, ConcurrentMap<NodeKey,CachedNode> cache, ChangeSetListener changeSetListener)`

    Constructor parameters in org.modeshape.jcr.cache.document with type arguments of type NodeKey
    Constructor and Description
    `WorkspaceCache(ExecutionContext context, String repositoryKey, String workspaceName, DocumentStore documentStore, DocumentTranslator translator, NodeKey rootKey, ConcurrentMap<NodeKey,CachedNode> cache, ChangeSetListener changeSetListener)`
    `WorkspaceCache(WorkspaceCache original, ConcurrentMap<NodeKey,CachedNode> cache, ChangeSetListener changeSetListener)`

  - ### Uses of NodeKey in org.modeshape.jcr.journal

    Methods in org.modeshape.jcr.journal that return types with arguments of type NodeKey
    Modifier and Type | Method and Description
    --- | ---
    `Set<NodeKey>` | JournalRecord.`changedNodes()` Returns the set of keys for the nodes which has been changed.

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

    Methods in org.modeshape.jcr.query that return NodeKey
    Modifier and Type | Method and Description
    --- | ---
    `protected static NodeKey` | NodeSequence.`keyFor(CachedNode node)`

    Methods in org.modeshape.jcr.query with parameters of type NodeKey
    Modifier and Type | Method and Description
    --- | ---
    `void` | CompositeIndexWriter.`addToIndex(String workspace, NodeKey key, Path path, Name primaryType, Set<Name> mixinTypes, Iterator<Property> propertiesIterator, NodeTypeSchemata schemata, IndexWriter.IndexingContext txnCtx)`
    `void` | CompositeIndexWriter.`updateIndex(String workspace, NodeKey key, Path path, Name primaryType, Set<Name> mixinTypes, Iterator<Property> properties, NodeTypeSchemata schemata, IndexWriter.IndexingContext txnCtx)`

    Method parameters in org.modeshape.jcr.query with type arguments of type NodeKey
    Modifier and Type | Method and Description
    --- | ---
    `static NodeSequence.Batch` | NodeSequence.`batchOfKeys(Collection<NodeKey> keys, float score, String workspaceName, RepositoryCache repository)` Create a batch of nodes around the supplied iterable container.
    `static NodeSequence.Batch` | NodeSequence.`batchOfKeys(Iterator<NodeKey> keys, Iterator<Float> scores, long nodeCount, String workspaceName, RepositoryCache repository)` Create a batch of nodes around the supplied iterator and the scores iterator.
    `static NodeSequence.Batch` | NodeSequence.`batchOfKeys(Iterator<NodeKey> keys, long nodeCount, float score, String workspaceName, NodeCache cache)` Create a batch of nodes around the supplied iterator.
    `static NodeSequence.Batch` | NodeSequence.`batchOfKeys(Iterator<NodeKey> keys, long nodeCount, float score, String workspaceName, RepositoryCache repository)` Create a batch of nodes around the supplied iterator.
    `void` | CompositeIndexWriter.`removeFromIndex(String workspace, Iterable<NodeKey> keys, IndexWriter.IndexingContext txnCtx)`
    `static NodeSequence` | NodeSequence.`withNodeKeys(Collection<NodeKey> keys, float score, String workspaceName, NodeCache cache)` Create a sequence of nodes that iterates over the supplied node keys.
    `static NodeSequence` | NodeSequence.`withNodeKeys(Collection<NodeKey> keys, float score, String workspaceName, RepositoryCache repository)` Create a sequence of nodes that iterates over the supplied node keys.
    `static NodeSequence` | NodeSequence.`withNodeKeys(Iterator<NodeKey> keys, long keyCount, float score, String workspaceName, NodeCache cache)` Create a sequence of nodes that iterates over the supplied node keys.
    `static NodeSequence` | NodeSequence.`withNodeKeys(Iterator<NodeKey> keys, long keyCount, float score, String workspaceName, RepositoryCache repository)` Create a sequence of nodes that iterates over the supplied node keys.

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

    Methods in org.modeshape.jcr.query.engine with parameters of type NodeKey
    Modifier and Type | Method and Description
    --- | ---
    `void` | QuerySources.BatchWriter.`add(NodeKey nodeKey, float score)`
    `void` | NoOpQueryIndexWriter.`addToIndex(String workspace, NodeKey key, Path path, Name primaryType, Set<Name> mixinTypes, Iterator<Property> propertiesIterator, NodeTypeSchemata schemata, IndexWriter.IndexingContext txnCtx)`
    `void` | NoOpQueryIndexWriter.`updateIndex(String workspace, NodeKey key, Path path, Name primaryType, Set<Name> mixinTypes, Iterator<Property> properties, NodeTypeSchemata schemata, IndexWriter.IndexingContext txnCtx)`

    Method parameters in org.modeshape.jcr.query.engine with type arguments of type NodeKey
    Modifier and Type | Method and Description
    --- | ---
    `void` | QuerySources.BatchWriter.`add(Iterable<NodeKey> nodeKeys, float score)`
    `void` | QuerySources.BatchWriter.`add(Iterator<NodeKey> nodeKeys, float score)`
    `void` | NoOpQueryIndexWriter.`removeFromIndex(String workspace, Iterable<NodeKey> keys, IndexWriter.IndexingContext txnCtx)`

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

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

  - ### Uses of NodeKey in org.modeshape.jcr.spi.index.provider

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

    Method parameters in org.modeshape.jcr.spi.index.provider with type arguments of type NodeKey
    Modifier and Type | Method and Description
    --- | ---
    `void` | ResultWriter.`add(Iterable<NodeKey> nodeKeys, float score)` Add to the current batch a series of node keys with the same score for each node key.
    `void` | ResultWriter.`add(Iterator<NodeKey> nodeKeys, float score)` Add to the current batch a series of node keys with the same score for each node key.
    `void` | IndexWriter.`removeFromIndex(String workspace, Iterable<NodeKey> keys, IndexWriter.IndexingContext txnCtx)`

  - ### Uses of NodeKey in org.modeshape.jcr.txn

    Methods in org.modeshape.jcr.txn with parameters of type NodeKey
    Modifier and Type | Method and Description
    --- | ---
    `void` | SynchronizedTransactions.SynchronizedMonitor.`recordAdd(String workspace, NodeKey key, Path path, Name primaryType, Set<Name> mixinTypes, Iterator<Property> propertiesIterator)`
    `void` | SynchronizedTransactions.SynchronizedMonitor.`recordUpdate(String workspace, NodeKey key, Path path, Name primaryType, Set<Name> mixinTypes, Iterator<Property> properties)`

    Method parameters in org.modeshape.jcr.txn with type arguments of type NodeKey
    Modifier and Type | Method and Description
    --- | ---
    `void` | SynchronizedTransactions.SynchronizedMonitor.`recordRemove(String workspace, Iterable<NodeKey> keys)`

  - ### Uses of NodeKey in org.modeshape.jcr.value

    Methods in org.modeshape.jcr.value that return NodeKey
    Modifier and Type | Method and Description
    --- | ---
    `NodeKey` | ValueTypeSystem.NodeKeyTypeFactory.`create(Object value)`
    `NodeKey` | ValueTypeSystem.NodeKeyTypeFactory.`create(String value)`

    Methods in org.modeshape.jcr.value that return types with arguments of type NodeKey
    Modifier and Type | Method and Description
    --- | ---
    `Comparator<NodeKey>` | ValueTypeSystem.NodeKeyTypeFactory.`getComparator()`
    `TypeSystem.TypeFactory<NodeKey>` | ValueTypeSystem.`getNodeKeyFactory()`
    `Class<NodeKey>` | ValueTypeSystem.NodeKeyTypeFactory.`getType()`

    Methods in org.modeshape.jcr.value with parameters of type NodeKey
    Modifier and Type | Method and Description
    --- | ---
    `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
    Modifier and Type | Method and Description
    --- | ---
    `NodeKey` | NodeKeyReference.`getNodeKey()`

    Methods in org.modeshape.jcr.value.basic with parameters of type NodeKey
    Modifier and Type | Method and Description
    --- | ---
    `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)`
    `static NodeIdentifierReferenceFactory` | NodeIdentifierReferenceFactory.`newInstance(NodeKey rootKey, TextDecoder decoder, ValueFactories factories, boolean weak, boolean simple)`

    Constructors in org.modeshape.jcr.value.basic with parameters of type NodeKey
    Constructor and Description
    `NodeIdentifierReferenceFactory(PropertyType type, TextDecoder decoder, ValueFactories valueFactories, boolean weak, boolean simple, NodeKey rootKey)`
    `NodeKeyReference(NodeKey key, boolean weak, boolean foreign)`
    `NodeKeyReference(NodeKey key, boolean weak, boolean foreign, boolean simple)`

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

    Methods in org.modeshape.jcr.value.binary with parameters of type NodeKey
    Modifier and Type | Method and Description
    --- | ---
    `BinaryValue` | BinaryStoreValueFactory.`create(NodeKey value)`

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