ModeShape Distribution 3.2.0.Final

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
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
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
 void JcrSession.SystemSessionCache.save(Set<NodeKey> toBeSaved, SessionCache otherSession, SessionCache.PreSave preSaveOperation)
           
 

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 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
 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).
 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)
          Copies into this node all the properties and children (deep copy) from the given source node.
 Map<NodeKey,NodeKey> MutableCachedNode.deepCopy(SessionCache cache, CachedNode sourceNode, SessionCache sourceCache)
          Copies into this node all the properties and children (deep copy) from the given source node.
protected  Set<NodeKey> AllPathsCache.getAdditionalParentKeys(CachedNode node, NodeCache cache)
           
 Set<NodeKey> CachedNode.getAdditionalParentKeys(NodeCache cache)
          Get the keys for all of the nodes (other than the primary parent) under which this node appears.
 Iterator<NodeKey> ChildReferences.getAllKeys()
          Get the keys for all of the children.
 Iterator<NodeKey> 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 NodeKeys of the transient nodes from this cache.
 Set<NodeKey> SessionCacheWrapper.getChangedNodeKeysAtOrBelow(CachedNode node)
           
 Set<NodeKey> SessionCache.getChangedNodeKeysAtOrBelow(CachedNode node)
          Returns a set with the NodeKeys of the transient nodes from this cache which are at or below the path of the given node
 Set<NodeKey> MutableCachedNode.getChangedReferrerNodes()
          Returns a set with all the referencing nodes (nodes which are referring this node) which have changed.
 Set<NodeKey> SessionCacheWrapper.getNodeKeysAtAndBelow(NodeKey nodeKey)
           
 Set<NodeKey> SessionCache.getNodeKeysAtAndBelow(NodeKey nodeKey)
          Returns a set with the NodeKeys of the existing nodes (persistent not transient & new) which are at and below the path of the node with the given key.
 Set<NodeKey> ReferentialIntegrityException.getReferrers()
          Get the set of node keys that contain REFERENCE properties to nodes being deleted, and therefore prevent the removal.
 Set<NodeKey> CachedNode.getReferrers(NodeCache cache, CachedNode.ReferenceType type)
          Get the keys of the nodes that have JCR REFERENCE and/or WEAK_REFERENCE properties pointing to this node.
 Set<NodeKey> ReferentialIntegrityException.getRemovedNodes()
          Get the set of keys to the nodes that were removed.
 Set<NodeKey> MutableCachedNode.removedChildren()
          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
 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 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 NodeKeys of the existing nodes (persistent not transient & new) which are at and below the path of the node with the given key.
 boolean ChildReferences.hasChild(NodeKey key)
          Determine if this contains a reference to the specified child.
 ChildReference ChildReferences.Changes.inserted(NodeKey key)
          Get the child reference for the inserted node with the supplied key.
 ChildReference ChildReferences.NoChanges.inserted(NodeKey key)
           
 boolean 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, Collection<Property> properties)
          Add to the index the information about a node.
 void SessionEnvironment.Monitor.recordUpdate(String workspace, NodeKey key, Path path, Name primaryType, Set<Name> mixinTypes, Iterator<Property> properties)
          Update the index to reflect the new state of the node.
 void MutableCachedNode.removeChild(SessionCache cache, NodeKey key)
          Remove the node from being a child of this node.
 boolean PathCache.removePath(NodeKey key)
           
 boolean AllPathsCache.removePath(NodeKey key)
           
 void MutableCachedNode.removeReferrer(SessionCache cache, NodeKey referrerKey, CachedNode.ReferenceType type)
          Remove from this node a reference with the given type from the node with the supplied key to this node.
 void MutableCachedNode.renameChild(SessionCache cache, NodeKey key, Name newName)
          Renames the child node.
 Name ChildReferences.Changes.renamed(NodeKey key)
          Return the new name for the child node with the supplied key.
 Name ChildReferences.NoChanges.renamed(NodeKey key)
           
 void MutableCachedNode.reorderChild(SessionCache cache, NodeKey key, NodeKey nextNode)
          Remove the node from being a child of this node and append it as a child before the supplied node.
 

Method parameters in org.modeshape.jcr.cache with type arguments of type NodeKey
 void SessionEnvironment.Monitor.recordRemove(String workspace, Iterable<NodeKey> keys)
          Remove from the index for the given workspace all of the nodes with the supplied keys.
 void 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
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> 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.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)
           
 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)
           
 void WritableSessionCache.createProjection(NodeKey nodeKey, String sourceName, String externalPath, String alias)
          Creates a projection for the given source and node, by specifying the external path and an optional alias.
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 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 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 WritableSessionCache.removeProjection(NodeKey federatedNodeKey, NodeKey externalNodeKey)
          Removes from the given federated node a projection pointing towards an external node.
 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.clearState(Iterable<NodeKey> savedNodesInOrder)
           
protected  long DocumentTranslator.insertChildren(EditableDocument document, Map<NodeKey,SessionNode.Insertions> insertionsByBeforeKey, Set<NodeKey> removals, Map<NodeKey,Name> newNames)
           
protected  long DocumentTranslator.insertChildren(EditableDocument document, Map<NodeKey,SessionNode.Insertions> insertionsByBeforeKey, Set<NodeKey> removals, Map<NodeKey,Name> newNames)
           
protected  long DocumentTranslator.insertChildren(EditableDocument document, Map<NodeKey,SessionNode.Insertions> insertionsByBeforeKey, Set<NodeKey> removals, Map<NodeKey,Name> newNames)
           
protected  ChangeSet WritableSessionCache.persistChanges(Iterable<NodeKey> changedNodesInOrder, SessionEnvironment.Monitor monitor)
          Persist the changes within an already-established transaction.
 void WritableSessionCache.save(Set<NodeKey> toBeSaved, SessionCache other, SessionCache.PreSave preSaveOperation)
          This method saves the changes made by both sessions within a single transaction.
 void ReadOnlySessionCache.save(Set<NodeKey> toBeSaved, SessionCache otherSession, SessionCache.PreSave preSaveOperation)
           
 

Constructors in org.modeshape.jcr.cache.document with parameters of type NodeKey
LazyCachedNode(NodeKey key, 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
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
 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.SynchronizedMonitor.recordAdd(String workspace, NodeKey key, Path path, Name primaryType, Set<Name> mixinTypes, Collection<Property> properties)
           
 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
 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
 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
NodeIdentifierReferenceFactory(NodeKey rootKey, TextDecoder decoder, ValueFactories factories, boolean weak)
           
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)
           
 


ModeShape Distribution 3.2.0.Final

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