ModeShape Distribution 3.0.0.Alpha6

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
 

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.
 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
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 CachedNode.getParentKey(NodeCache cache)
          Get the node key for this node's primary parent.
 NodeKey NodeCache.getRootKey()
          Get the node key for the root node.
 NodeKey RepositoryCache.getSystemKey()
           
 NodeKey NodeKey.withId(String identifier)
           
 NodeKey NodeKey.withRandomId()
           
 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.
 Set<NodeKey> SessionCache.getChangedNodeKeys()
          Returns a set with the NodeKeys of the transient nodes from this cache.
 Set<NodeKey> SessionCache.getChangedNodeKeysAtOrBelow(CachedNode node)
          Returns a set with the NodeKeys of the transient nodes from this cache which are at or below the path of the given node
 Set<NodeKey> MutableCachedNode.getChangedReferrerNodes()
          Returns a set with all the referencing nodes (nodes which are referring this node) which have changed.
 Set<NodeKey> SessionCache.getNodeKeysAtAndBelow(NodeKey nodeKey)
          Returns a set with the NodeKeys of the existing nodes (persistent not transient & new) which are at and below the path of the node with the given key.
 Set<NodeKey> ReferentialIntegrityException.getReferrers()
          Get the set of node keys that contain REFERENCE properties to nodes being deleted, and therefore prevent the removal.
 Set<NodeKey> CachedNode.getReferrers(NodeCache cache, CachedNode.ReferenceType type)
          Get the keys of the nodes that have JCR REFERENCE and/or WEAK_REFERENCE properties pointing to this node.
 Set<NodeKey> ReferentialIntegrityException.getRemovedNodes()
          Get the set of keys to the nodes that were removed.
 Set<NodeKey> MutableCachedNode.removedChildren()
          Returns a set with the keys of the children which have been removed for this node.
 

Methods in org.modeshape.jcr.cache with parameters of type NodeKey
 void MutableCachedNode.addReferrer(SessionCache cache, NodeKey referrerKey, CachedNode.ReferenceType type)
          Adds to this node a reference with the given type from the node with the supplied key to this node.
 int NodeKey.compareTo(NodeKey that)
           
 int ChildReferences.Context.consume(Name name, NodeKey key)
          Consume the next child with the supplied name and key.
 int ChildReferences.NoContext.consume(Name name, NodeKey key)
           
 int ChildReferences.NoSnsIndexesContext.consume(Name name, NodeKey key)
           
 int ChildReferences.SingleNameContext.consume(Name name, NodeKey key)
           
 int ChildReferences.BasicContext.consume(Name name, NodeKey key)
           
 int ChildReferences.WithChanges.consume(Name name, NodeKey key)
           
 MutableCachedNode MutableCachedNode.createChild(SessionCache cache, NodeKey key, Name name, Iterable<Property> properties)
          Create a new node as a child of this node with the supplied name and properties.
 MutableCachedNode MutableCachedNode.createChild(SessionCache cache, NodeKey key, Name name, Property firstProperty, Property... additionalProperties)
          Create a new node as a child of this node with the supplied name and properties.
 void SessionCache.destroy(NodeKey key)
          Destroy the subgraph with the supplied node as the top node in the subgraph.
 ChildReference ChildReferences.getChild(NodeKey key)
          Look for the child reference that has the node key.
 ChildReference ChildReferences.getChild(NodeKey key, ChildReferences.Context context)
          Look for the child reference that has the node key.
 CachedNode NodeCache.getNode(NodeKey key)
          Get the cached representation of the node with the supplied node key.
 Set<NodeKey> SessionCache.getNodeKeysAtAndBelow(NodeKey nodeKey)
          Returns a set with the NodeKeys of the existing nodes (persistent not transient & new) which are at and below the path of the node with the given key.
 boolean ChildReferences.hasChild(NodeKey key)
          Determine if this contains a reference to the specified child.
 ChildReference ChildReferences.Changes.inserted(NodeKey key)
          Get the child reference for the inserted node with the supplied key.
 ChildReference ChildReferences.NoChanges.inserted(NodeKey key)
           
 boolean SessionCache.isDestroyed(NodeKey key)
          Return whether the node with the supplied key has been removed using this session but not yet persisted.
 void 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)
           
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()
           
 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)
           
 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)
           
 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)
           
 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)
           
 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)
           
 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)
           
 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)
           
 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)
           
 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)
           
 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)
           
 

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
           
 

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)
           
 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 WorkspaceCache.getRootKey()
           
 NodeKey AbstractSessionCache.getRootKey()
           
protected  NodeKey SessionNode.newParent()
           
 

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()
           
 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)
           
 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)
           
 void WritableSessionCache.destroy(NodeKey key)
           
 void ReadOnlySessionCache.destroy(NodeKey key)
           
 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)
           
 void 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)
           
 void DocumentTranslator.optimizeChildrenBlocks(NodeKey key, EditableDocument document, int targetCountPerBlock, int tolerance)
           
 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)
           
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)
           
 


ModeShape Distribution 3.0.0.Alpha6

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