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

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

    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 org.infinispan.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` | NodeCache.`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()`

    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)`
    `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
    Modifier and Type | Method and Description
    --- | ---
    `void` | RecordingChanges.`setChangedNodes(Set<NodeKey> keys)`

    Constructors in org.modeshape.jcr.cache.change with parameters of type NodeKey
    Constructor and Description
    `AbstractNodeChange(NodeKey key, Path path)`
    `AbstractPropertyChange(NodeKey key, Path nodePath, Property property)` Creates a new property change event
    `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
    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)`
    `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.query

    Methods in org.modeshape.jcr.query that return NodeKey
    Modifier and Type | Method and Description
    --- | ---
    `NodeKey` | QueryResults.Location.`getKey()`

    Methods in org.modeshape.jcr.query with parameters of type NodeKey
    Modifier and Type | Method and Description
    --- | ---
    `void` | QueryIndexing.`addToIndex(String workspace, NodeKey key, Path path, Name primaryType, Set<Name> mixinTypes, Iterator<Property> propertiesIterator, 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
    Modifier and Type | Method and Description
    --- | ---
    `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
    Constructor and Description
    `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
    Modifier and Type | Method and Description
    --- | ---
    `void` | BasicLuceneSchema.`addToIndex(String workspace, NodeKey key, Path path, Name primaryType, Set<Name> mixinTypes, Iterator<Property> propertiesIterator, 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
    Modifier and Type | Method and Description
    --- | ---
    `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
    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 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
    --- | ---
    `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)`
    `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.