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

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

Packages that use NodeKey
org.modeshape.jcr |
org.modeshape.jcr.cache |
org.modeshape.jcr.cache.change |
org.modeshape.jcr.cache.document |
org.modeshape.jcr.query | The Query API provides a mechanism for building and executing queries.
org.modeshape.jcr.query.lucene.basic | The "basic" `Lucene schema` has a single index in which all node and property information are indexed into separate fields.
org.modeshape.jcr.txn |
org.modeshape.jcr.value | Nodes in a graph contain properties, and this package defines the interfaces, classes and exceptions for representing and working with properties and their values.
org.modeshape.jcr.value.basic | A set of basic implementations of the various interfaces defined in `org.modeshape.jcr.value`.
org.modeshape.jcr.value.binary |

Uses of NodeKey in org.modeshape.jcr

Fields in org.modeshape.jcr with type parameters of type NodeKey
`protected BlockingQueue<NodeKey>` | `BackupService.BackupActivity.changedDocumentQueue`

Methods in org.modeshape.jcr that return NodeKey
`protected NodeKey` | `SystemContent.keyForNamespaceUri(String namespaceUri)`
`NodeKey` | `SystemContent.locksKey()`
`NodeKey` | `SystemContent.namespacesKey()`
`NodeKey` | `SystemContent.nodeTypesKey()`
`NodeKey` | `SystemContent.systemKey()`
`NodeKey` | `SystemContent.versionHistoryNodeKeyFor(NodeKey versionableNodeKey)`
`NodeKey` | `SystemContent.versionStorageKey()`

Methods in org.modeshape.jcr with parameters of type NodeKey
`protected SchematicEntry` | `JcrSession.entryForNode(NodeKey nodeKey)`
`boolean` | `SystemContent.hasVersionHistory(NodeKey versionableNodeKey)`
`protected MutableCachedNode` | `SystemContent.initializeVersionStorage(NodeKey versionableNodeKey, NodeKey versionHistoryKey, NodeKey versionKey, Name primaryTypeName, Set<Name> mixinTypeNames, Path versionHistoryPath, NodeKey originalVersionKey, DateTime now)` Create and initialize the version history structure for a versionable node with the supplied UUID.
`protected boolean` | `JcrSession.isForeignKey(NodeKey key)` Checks if the node given key is foreign by comparing the source key & workspace key against the same keys from this session's root.
`protected boolean` | `JcrSession.nodeExists(NodeKey key)` Utility method to determine if the node with the specified key still exists within the transient & persisted state.
`protected String` | `JcrSession.nodeIdentifier(NodeKey key)` Returns a string representing a node's identifier, based on whether the node is foreign or not.
`MutableCachedNode` | `SystemContent.recordNewVersion(CachedNode versionableNode, SessionCache cacheForVersionableNode, Path versionHistoryPath, NodeKey originalVersionKey, Collection<Property> versionableProperties, DateTime now, AtomicReference<MutableCachedNode> frozenNodeOutput)` The method efficiently updates the JCR version history and storage with a new version of a node being checked in.
`NodeKey` | `SystemContent.versionHistoryNodeKeyFor(NodeKey versionableNodeKey)`

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

Uses of NodeKey in org.modeshape.jcr.cache

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

Methods in org.modeshape.jcr.cache that return types with arguments of type NodeKey
`Map<NodeKey,NodeKey>` | `MutableCachedNode.deepCopy(SessionCache cache, CachedNode sourceNode, SessionCache sourceCache)` Copies into this node all the properties and children (deep copy) from the given source node.
`Map<NodeKey,NodeKey>` | `MutableCachedNode.deepCopy(SessionCache cache, CachedNode sourceNode, SessionCache sourceCache)` Copies into this node all the properties and children (deep copy) from the given source node.
`Set<NodeKey>` | `CachedNode.getAdditionalParentKeys(NodeCache cache)` Get the keys for all of the nodes (other than the `primary parent`) under which this node appears.
`Iterator<NodeKey>` | `ChildReferences.getAllKeys()` Get the keys for all of the children.
`Iterator<NodeKey>` | `NodeCache.getAllNodeKeys()` Get an iterator over all node keys within this cache.
`Iterator<NodeKey>` | `NodeCache.getAllNodeKeysAtAndBelow(NodeKey startingKey)` Get an iterator over all keys for the supplied node and all its descendants.
`Set<NodeKey>` | `SessionCache.getChangedNodeKeys()` Returns a set with the `NodeKey`s of the transient nodes from this cache.
`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>` | `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()` Returns a set with the keys of the children which have been removed for this node.

Methods in org.modeshape.jcr.cache with parameters of type NodeKey
`void` | `MutableCachedNode.addReferrer(SessionCache cache, NodeKey referrerKey, CachedNode.ReferenceType type)` Adds to this node a reference with the given type from the node with the supplied key to this node.
`int` | `NodeKey.compareTo(NodeKey that)`
`int` | `ChildReferences.Context.consume(Name name, NodeKey key)` Consume the next child with the supplied name and key.
`int` | `ChildReferences.NoContext.consume(Name name, NodeKey key)`
`int` | `ChildReferences.NoSnsIndexesContext.consume(Name name, NodeKey key)`
`int` | `ChildReferences.SingleNameContext.consume(Name name, NodeKey key)`
`int` | `ChildReferences.BasicContext.consume(Name name, NodeKey key)`
`int` | `ChildReferences.WithChanges.consume(Name name, NodeKey key)`
`MutableCachedNode` | `MutableCachedNode.createChild(SessionCache cache, NodeKey key, Name name, Iterable<Property> properties)` Create a new node as a child of this node with the supplied name and properties.
`MutableCachedNode` | `MutableCachedNode.createChild(SessionCache cache, NodeKey key, Name name, Property firstProperty, Property... additionalProperties)` Create a new node as a child of this node with the supplied name and properties.
`void` | `SessionCache.destroy(NodeKey key)` Destroy the subgraph with the supplied node as the top node in the subgraph.
`Iterator<NodeKey>` | `NodeCache.getAllNodeKeysAtAndBelow(NodeKey startingKey)` Get an iterator over all keys for the supplied node and all its descendants.
`ChildReference` | `ChildReferences.getChild(NodeKey key)` Look for the child reference that has the node key.
`ChildReference` | `ChildReferences.getChild(NodeKey key, ChildReferences.Context context)` Look for the child reference that has the node key.
`CachedNode` | `NodeCache.getNode(NodeKey key)` Get the cached representation of the node with the supplied node key.
`Set<NodeKey>` | `SessionCache.getNodeKeysAtAndBelow(NodeKey nodeKey)` Returns a set with the `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` | `SessionCache.isDestroyed(NodeKey key)` Return whether the node with the supplied key has been removed using this session but not yet persisted.
`boolean` | `MutableCachedNode.linkChild(SessionCache cache, NodeKey childKey, Name name)` Link the existing node with the supplied key to be appended as a child of this node.
`void` | `MutableCachedNode.moveChild(SessionCache cache, NodeKey key, MutableCachedNode newParent, Name newName)` Remove the node from being a child of this node and append it as a child of the supplied node.
`MutableCachedNode` | `SessionCache.mutable(NodeKey key)` Get a mutable form of the node with the supplied key.
`void` | `SessionEnvironment.Monitor.recordAdd(String workspace, NodeKey key, Path path, Name primaryType, Set<Name> mixinTypes, Collection<Property> properties)` Add to the index the information about a node.
`void` | `SessionEnvironment.Monitor.recordUpdate(String workspace, NodeKey key, Path path, Name primaryType, Set<Name> mixinTypes, Iterator<Property> properties)` Update the index to reflect the new state of the node.
`void` | `MutableCachedNode.removeChild(SessionCache cache, NodeKey key)` Remove the node from being a child of this node.
`boolean` | `PathCache.removePath(NodeKey key)`
`void` | `MutableCachedNode.removeReferrer(SessionCache cache, NodeKey referrerKey, CachedNode.ReferenceType type)` Remove from this node a reference with the given type from the node with the supplied key to this node.
`void` | `MutableCachedNode.renameChild(SessionCache cache, NodeKey key, Name newName)` Renames the child node.
`Name` | `ChildReferences.Changes.renamed(NodeKey key)` Return the new name for the child node with the supplied key.
`Name` | `ChildReferences.NoChanges.renamed(NodeKey key)`
`void` | `MutableCachedNode.reorderChild(SessionCache cache, NodeKey key, NodeKey nextNode)` Remove the node from being a child of this node and append it as a child before the supplied node.

Method parameters in org.modeshape.jcr.cache with type arguments of type NodeKey
`void` | `SessionEnvironment.Monitor.recordRemove(String workspace, Iterable<NodeKey> keys)` Remove from the index for the given workspace all of the nodes with the supplied keys.

Constructors in org.modeshape.jcr.cache with parameters of type NodeKey
`ChildReference(NodeKey key, Name name, int snsIndex)`
`ChildReference(NodeKey key, Path.Segment segment)`
`LockFailureException(NodeKey key)`
`LockFailureException(NodeKey key, String message)`
`LockFailureException(NodeKey key, String message, Throwable cause)`
`LockFailureException(NodeKey key, Throwable cause)`
`NodeNotFoundException(NodeKey key)`
`NodeNotFoundException(NodeKey key, String message)`
`NodeNotFoundException(NodeKey key, String message, Throwable cause)`
`NodeNotFoundException(NodeKey key, Throwable cause)`
`NodeNotFoundInParentException(NodeKey key, NodeKey parentKey)`
`PathNotFoundException(Path pathNotFound, NodeKey keyForLowestExistingAncestor, Path pathForLowestExistingAncestor)`
`PathNotFoundException(Path pathNotFound, NodeKey keyForLowestExistingAncestor, Path pathForLowestExistingAncestor, String message)`
`PathNotFoundException(Path pathNotFound, NodeKey keyForLowestExistingAncestor, Path pathForLowestExistingAncestor, String message, Throwable cause)`
`PathNotFoundException(Path pathNotFound, NodeKey keyForLowestExistingAncestor, Path pathForLowestExistingAncestor, Throwable cause)`

Constructor parameters in org.modeshape.jcr.cache with type arguments of type NodeKey
`ReferentialIntegrityException(Set<NodeKey> removedNodes, Set<NodeKey> referrers)`
`ReferentialIntegrityException(Set<NodeKey> removedNodes, Set<NodeKey> referrers)`

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

Methods in org.modeshape.jcr.cache.change that return NodeKey
`NodeKey` | `AbstractNodeChange.getKey()`
`NodeKey` | `NodeMoved.getNewParent()` Get the parent under which the node now appears.
`NodeKey` | `NodeMoved.getOldParent()` Get the parent under which the node formerly appeared.
`NodeKey` | `NodeSequenced.getOutputNodeKey()` Get the key of the top-level node that was output by the sequencer.
`NodeKey` | `NodeReordered.getParent()`
`NodeKey` | `NodeRemoved.getParentKey()` Get the key for the parent under which the new node was added.
`NodeKey` | `NodeAdded.getParentKey()` Get the key for the parent under which the new node was added.

Methods in org.modeshape.jcr.cache.change that return types with arguments of type NodeKey
`Set<NodeKey>` | `RecordingChanges.changedNodes()`
`Set<NodeKey>` | `ChangeSet.changedNodes()`

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

Method parameters in org.modeshape.jcr.cache.change with type arguments of type NodeKey
`void` | `RecordingChanges.setChangedNodes(Set<NodeKey> keys)`

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

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

Fields in org.modeshape.jcr.cache.document with type parameters of type NodeKey
`protected static Iterator<NodeKey>` | `ImmutableChildReferences.EMPTY_KEY_ITERATOR`
`protected Map<NodeKey,NodeKey>` | `SessionNode.DeepCopy.linkedPlaceholdersToOriginal`
`protected Map<NodeKey,NodeKey>` | `SessionNode.DeepCopy.linkedPlaceholdersToOriginal`
`protected Map<NodeKey,NodeKey>` | `SessionNode.DeepCopy.sourceToTargetKeys`
`protected Map<NodeKey,NodeKey>` | `SessionNode.DeepCopy.sourceToTargetKeys`

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

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

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

Method parameters in org.modeshape.jcr.cache.document with type arguments of type NodeKey
`protected void` | `WritableSessionCache.clearModifiedState(Iterable<NodeKey> savedNodesInOrder)`
`protected void` | `WritableSessionCache.clearState(Iterable<NodeKey> savedNodesInOrder)`
`protected long` | `DocumentTranslator.insertChildren(EditableDocument document, Map<NodeKey,SessionNode.Insertions> insertionsByBeforeKey, Set<NodeKey> removals, Map<NodeKey,Name> newNames)`
`protected long` | `DocumentTranslator.insertChildren(EditableDocument document, Map<NodeKey,SessionNode.Insertions> insertionsByBeforeKey, Set<NodeKey> removals, Map<NodeKey,Name> newNames)`
`protected long` | `DocumentTranslator.insertChildren(EditableDocument document, Map<NodeKey,SessionNode.Insertions> insertionsByBeforeKey, Set<NodeKey> removals, Map<NodeKey,Name> newNames)`
`protected ChangeSet` | `WritableSessionCache.persistChanges(Iterable<NodeKey> changedNodesInOrder, SessionEnvironment.Monitor monitor)` Persist the changes within an already-established transaction.

Constructors in org.modeshape.jcr.cache.document with parameters of type NodeKey
`LazyCachedNode(NodeKey key)`
`LazyCachedNode(NodeKey key, Document document)`
`NodeCacheIterator(NodeCache cache, NodeKey startingNode)`
`SessionNode(NodeKey key, boolean isNew)`
`WorkspaceCache(ExecutionContext context, String repositoryKey, String workspaceName, SchematicDb database, long largeValueSize, NodeKey rootKey, ChangeSetListener changeSetListener)`

Uses of NodeKey in org.modeshape.jcr.query

Methods in org.modeshape.jcr.query that return NodeKey
`NodeKey` | `QueryResults.Location.getKey()`

Methods in org.modeshape.jcr.query with parameters of type NodeKey
`void` | `QueryIndexing.addToIndex(String workspace, NodeKey key, Path path, Name primaryType, Set<Name> mixinTypes, Collection<Property> properties, NodeTypeSchemata schemata, org.hibernate.search.backend.TransactionContext txnCtx)` Add to the index the information about a node.
`void` | `QueryIndexing.updateIndex(String workspace, NodeKey key, Path path, Name primaryType, Set<Name> mixinTypes, Iterator<Property> properties, NodeTypeSchemata schemata, org.hibernate.search.backend.TransactionContext txnCtx)` Update the index to reflect the new state of the node.

Method parameters in org.modeshape.jcr.query with type arguments of type NodeKey
`void` | `QueryIndexing.removeFromIndex(String workspace, Iterable<NodeKey> keys, org.hibernate.search.backend.TransactionContext txnCtx)`

Constructors in org.modeshape.jcr.query with parameters of type NodeKey
`QueryResults.Location(Path path, NodeKey key)`

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

Methods in org.modeshape.jcr.query.lucene.basic with parameters of type NodeKey
`void` | `BasicLuceneSchema.addToIndex(String workspace, NodeKey key, Path path, Name primaryType, Set<Name> mixinTypes, Collection<Property> properties, NodeTypeSchemata schemata, org.hibernate.search.backend.TransactionContext txnCtx)`
`void` | `BasicLuceneSchema.updateIndex(String workspace, NodeKey key, Path path, Name primaryType, Set<Name> mixinTypes, Iterator<Property> properties, NodeTypeSchemata schemata, org.hibernate.search.backend.TransactionContext txnCtx)`

Method parameters in org.modeshape.jcr.query.lucene.basic with type arguments of type NodeKey
`void` | `BasicLuceneSchema.removeFromIndex(String workspace, Iterable<NodeKey> keys, org.hibernate.search.backend.TransactionContext txnCtx)`

Uses of NodeKey in org.modeshape.jcr.txn

Methods in org.modeshape.jcr.txn with parameters of type NodeKey
`void` | `SynchronizedTransactions.AccumulatingMonitor.recordAdd(String workspace, NodeKey key, Path path, Name primaryType, Set<Name> mixinTypes, Collection<Property> properties)`
`void` | `SynchronizedTransactions.AccumulatingMonitor.recordUpdate(String workspace, NodeKey key, Path path, Name primaryType, Set<Name> mixinTypes, Iterator<Property> properties)`

Method parameters in org.modeshape.jcr.txn with type arguments of type NodeKey
`void` | `SynchronizedTransactions.AccumulatingMonitor.recordRemove(String workspace, Iterable<NodeKey> keys)`

Constructors in org.modeshape.jcr.txn with parameters of type NodeKey
`SynchronizedTransactions.AddCall(String workspace, NodeKey key, Path path, Name primaryType, Set<Name> mixinTypes, Collection<Property> properties)`
`SynchronizedTransactions.UpdateCall(String workspace, NodeKey key, Path path, Name primaryType, Set<Name> mixinTypes, Iterator<Property> properties)`

Constructor parameters in org.modeshape.jcr.txn with type arguments of type NodeKey
`SynchronizedTransactions.RemoveCall(String workspace, Iterable<NodeKey> keys)`

Uses of NodeKey in org.modeshape.jcr.value

Methods in org.modeshape.jcr.value with parameters of type NodeKey
`T` | `ValueFactory.create(NodeKey value)` Create a value from a `NodeKey`.
`T[]` | `ValueFactory.create(NodeKey[] value)` Create an array of values from an array of `NodeKey`.
`Reference[]` | `ReferenceFactory.create(NodeKey[] value, boolean foreign)`
`Reference` | `ReferenceFactory.create(NodeKey value, boolean foreign)`

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

Methods in org.modeshape.jcr.value.basic that return NodeKey
`NodeKey` | `NodeKeyReference.getNodeKey()`

Methods in org.modeshape.jcr.value.basic with parameters of type NodeKey
`UUID` | `UuidValueFactory.create(NodeKey value)`
`URI` | `UriValueFactory.create(NodeKey value)`
`String` | `StringValueFactory.create(NodeKey value)`
`Reference` | `ReferenceValueFactory.create(NodeKey value)`
`Path` | `PathValueFactory.create(NodeKey value)`
`Object` | `ObjectValueFactory.create(NodeKey value)`
`Name` | `NameValueFactory.create(NodeKey value)`
`Long` | `LongValueFactory.create(NodeKey value)`
`DateTime` | `JodaDateTimeValueFactory.create(NodeKey value)`
`Double` | `DoubleValueFactory.create(NodeKey value)`
`BigDecimal` | `DecimalValueFactory.create(NodeKey value)`
`Boolean` | `BooleanValueFactory.create(NodeKey value)`
`T[]` | `AbstractValueFactory.create(NodeKey[] values)`
`Reference[]` | `ReferenceValueFactory.create(NodeKey[] values, boolean foreign)`
`Reference` | `ReferenceValueFactory.create(NodeKey value, boolean foreign)`

Constructors in org.modeshape.jcr.value.basic with parameters of type NodeKey
`NodeKeyReference(NodeKey key, boolean weak, boolean isForeign)`

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

Methods in org.modeshape.jcr.value.binary with parameters of type NodeKey
`BinaryValue` | `BinaryStoreValueFactory.create(NodeKey value)`

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

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