Uses of Interface
org.jboss.cache.NodeSPI

Packages that use NodeSPI

org.jboss.cache
org.jboss.cache.commands.write
org.jboss.cache.interceptors
org.jboss.cache.invocation
org.jboss.cache.loader
org.jboss.cache.lock
org.jboss.cache.optimistic
org.jboss.cache.statetransfer

Uses of NodeSPI in org.jboss.cache

Fields in org.jboss.cache declared as NodeSPI

protected NodeSPI

UnversionedNode.delegate

Methods in org.jboss.cache that return NodeSPI

NodeSPI	UnversionedNode.addChildDirect(Fqn f)
NodeSPI<K,V>	NodeSPI.addChildDirect(Fqn childName) Adds a child directly to a Node.
NodeSPI	UnversionedNode.addChildDirect(Fqn f, boolean notify)
NodeSPI<K,V>	NodeSPI.addChildDirect(Fqn f, boolean notify) Same as addChildDirect(Fqn) except that it optionally allows you to suppress notification events for the creation of this node.
NodeSPI	UnversionedNode.addChildDirect(Object childName, boolean notify)
NodeSPI<K,V>	NodeSPI.addChildDirect(Object childName, boolean notify) Same as addChildDirect(Fqn, boolean) except that it just takes a child name
NodeSPI<K,V>	NodeFactory.createDataNode(Object childName, Fqn fqn, NodeSPI<K,V> parent, Map<K,V> data, boolean mapSafe) Creates a new Node instance.
NodeSPI<K,V>	NodeFactory.createRootDataNode()
NodeSPI	UnversionedNode.getChildDirect(Fqn fqn)
NodeSPI<K,V>	NodeSPI.getChildDirect(Fqn childName) Retrives a child directly by fully qualified name.
NodeSPI	UnversionedNode.getChildDirect(Object childName)
NodeSPI<K,V>	NodeSPI.getChildDirect(Object childName) Retrives a child directly by name.
NodeSPI	UnversionedNode.getDelegate()
NodeSPI<K,V>	CacheSPI.getNode(Fqn<?> f) Overrides Cache.getNode(Fqn) to return a NodeSPI instead of a Node.
NodeSPI<K,V>	CacheSPI.getNode(String s) Overrides Cache.getNode(String) to return a NodeSPI instead of a Node.
NodeSPI<K,V>	NodeSPI.getOrCreateChild(Object name, GlobalTransaction tx) Returns an existing child or creates a new one using a global transaction.
NodeSPI	UnversionedNode.getOrCreateChild(Object child_name, GlobalTransaction gtx, boolean notify)
NodeSPI<K,V>	VersionedNode.getParent() Returns the parent.
NodeSPI	UnversionedNode.getParent() Returns a parent by checking the TreeMap by name.
NodeSPI<K,V>	NodeSPI.getParent() Returns the parent node as a NodeSPI, instead of Node from Node.getParent(), and is otherwise identical.
NodeSPI	DataContainerImpl.getRoot()
NodeSPI	DataContainer.getRoot() Retrieves the root node.
NodeSPI<K,V>	CacheSPI.getRoot() Overrides Cache.getRoot() to return a NodeSPI instead of a Node.
NodeSPI	DataContainerImpl.peek(Fqn fqn) Finds a node given a fully qualified name, directly off the interceptor chain.
NodeSPI	DataContainer.peek(Fqn fqn) Finds a node given a fully qualified name, directly off the interceptor chain.
NodeSPI	DataContainerImpl.peek(Fqn<?> fqn, boolean includeDeletedNodes)
NodeSPI	DataContainer.peek(Fqn<?> fqn, boolean includeDeletedNodes) Same as calling peek(fqn, includeDeletedNodes, false).
NodeSPI<K,V>	CacheSPI.peek(Fqn<?> fqn, boolean includeDeletedNodes) Returns a node without accessing the interceptor chain.
NodeSPI	DataContainerImpl.peek(Fqn<?> fqn, boolean includeDeletedNodes, boolean includeInvalidNodes)
NodeSPI	DataContainer.peek(Fqn<?> fqn, boolean includeDeletedNodes, boolean includeInvalidNodes) Peeks for a specified node.
NodeSPI<K,V>	CacheSPI.peek(Fqn<?> fqn, boolean includeDeletedNodes, boolean includeInvalidNodes) Returns a node without accessing the interceptor chain, optionally returning nodes that are marked as invalid (Node.isValid() == false).
NodeSPI	DataContainerImpl.peekStrict(GlobalTransaction gtx, Fqn fqn, boolean includeInvalid)
NodeSPI	DataContainer.peekStrict(GlobalTransaction gtx, Fqn fqn, boolean includeInvalid) Similar to DataContainer.peekVersioned(Fqn, org.jboss.cache.optimistic.DataVersion) except that it throws a NodeNotExistsException if the node cannot be found.
NodeSPI	DataContainerImpl.peekVersioned(Fqn fqn, DataVersion version)
NodeSPI	DataContainer.peekVersioned(Fqn fqn, DataVersion version) Finds a node given a fully qualified name and DataVersion.
NodeSPI	DataContainerImpl.peekVersioned(Fqn fqn, DataVersion version, boolean includeInvalidNodes)
NodeSPI	DataContainer.peekVersioned(Fqn fqn, DataVersion version, boolean includeInvalidNodes) Searches for a specific node, with a specific data version and, optionally, invalid nodes as well, but not deleted nodes.

Methods in org.jboss.cache that return types with arguments of type NodeSPI

Set<NodeSPI>	UnversionedNode.getChildrenDirect()
Set<NodeSPI<K,V>>	NodeSPI.getChildrenDirect() Functionally the same as Node.getChildren() except that it operates directly on the node and bypasses the interceptor chain.
Set<NodeSPI>	UnversionedNode.getChildrenDirect(boolean includeMarkedForRemoval)
Set<NodeSPI<K,V>>	NodeSPI.getChildrenDirect(boolean includeMarkedAsDeleted) Retrieves children (directly), optionally including any marked as deleted nodes.

Methods in org.jboss.cache with parameters of type NodeSPI

void	UnversionedNode.addChildDirect(NodeSPI child)
void	NodeSPI.addChildDirect(NodeSPI<K,V> child) Directly adds the node passed in to the children map of the current node.
List<NodeData>	DataContainerImpl.buildNodeData(List<NodeData> list, NodeSPI node)
List<NodeData>	DataContainer.buildNodeData(List<NodeData> list, NodeSPI node) Prepares a list of NodeData objects for a specified node and all its children.
NodeSPI<K,V>	NodeFactory.createDataNode(Object childName, Fqn fqn, NodeSPI<K,V> parent, Map<K,V> data, boolean mapSafe) Creates a new Node instance.
WorkspaceNode<K,V>	NodeFactory.createWorkspaceNode(NodeSPI<K,V> dataNode, TransactionWorkspace workspace)
void	UnversionedNode.setDelegate(NodeSPI delegate)
void	DataContainerImpl.setRoot(NodeSPI root) Sets the root node reference to the node passed in.

Constructors in org.jboss.cache with parameters of type NodeSPI

VersionedNode(Fqn fqn, NodeSPI<K,V> parent, Map<K,V> data, CacheSPI<K,V> cache)

Uses of NodeSPI in org.jboss.cache.commands.write

Fields in org.jboss.cache.commands.write declared as NodeSPI

protected NodeSPI

RemoveNodeCommand.targetNode

Methods in org.jboss.cache.commands.write that return NodeSPI

protected NodeSPI

InvalidateCommand.enforceNodeLoading() //TODO: 2.2.0: rather than using CacheSPI this should use peek().

Methods in org.jboss.cache.commands.write with parameters of type NodeSPI

protected void

InvalidateCommand.invalidateNode(NodeSPI node) mark the node to be removed (and all children) as invalid so anyone holding a direct reference to it will be aware that it is no longer valid.

Uses of NodeSPI in org.jboss.cache.interceptors

Methods in org.jboss.cache.interceptors that return NodeSPI

NodeSPI

Interceptor.peekNode(InvocationContext ctx, Fqn f, boolean forceRefresh, boolean includeDeletedNodes, boolean includeInvalidNodes) Deprecated. First checks the invocation context for previously obtained reference to a node, if this doesn't exist, performs a cache.peek() and holds on to the node reference.

Methods in org.jboss.cache.interceptors with parameters of type NodeSPI

protected void	OptimisticInterceptor.greedyGetFqns(List<Fqn> list, NodeSPI<?,?> n, Fqn newBase) Adds the Fqn of the node as well as all children and childrens children to the list.
void	PessimisticLockInterceptor.lockAllForRemoval(NodeSPI node, InvocationContext ctx, TransactionEntry entry) Acquires write locks on the node and all child nodes, adding children to the list of removed nodes in the context.
protected WorkspaceNode	OptimisticInterceptor.lockAndCreateWorkspaceNode(NodeFactory nodeFactory, NodeSPI node, TransactionWorkspace workspace, GlobalTransaction gtx, long timeout)

Uses of NodeSPI in org.jboss.cache.invocation

Classes in org.jboss.cache.invocation that implement NodeSPI

class

NodeInvocationDelegate<K,V> The delegate that users (and interceptor authors) interact with when they obtain a node from the cache or another node.

Methods in org.jboss.cache.invocation that return NodeSPI

NodeSPI<K,V>	NodeInvocationDelegate.addChildDirect(Fqn childName)
NodeSPI<K,V>	NodeInvocationDelegate.addChildDirect(Fqn f, boolean notify)
NodeSPI<K,V>	NodeInvocationDelegate.addChildDirect(Object childName, boolean notify)
NodeSPI<K,V>	NodeInvocationDelegate.getChildDirect(Fqn childName)
NodeSPI<K,V>	NodeInvocationDelegate.getChildDirect(Object childName)
NodeSPI<K,V>	CacheInvocationDelegate.getNode(Fqn<?> fqn)
NodeSPI<K,V>	CacheInvocationDelegate.getNode(String fqn)
NodeSPI<K,V>	NodeInvocationDelegate.getOrCreateChild(Object name, GlobalTransaction tx)
NodeSPI<K,V>	NodeInvocationDelegate.getParent()
NodeSPI<K,V>	CacheInvocationDelegate.getRoot()
NodeSPI<K,V>	CacheInvocationDelegate.peek(Fqn fqn, boolean includeDeletedNodes)
NodeSPI<K,V>	CacheInvocationDelegate.peek(Fqn fqn, boolean includeDeletedNodes, boolean includeInvalidNodes)

Methods in org.jboss.cache.invocation that return types with arguments of type NodeSPI

Set<NodeSPI<K,V>>	NodeInvocationDelegate.getChildrenDirect()
Set<NodeSPI<K,V>>	NodeInvocationDelegate.getChildrenDirect(boolean includeMarkedAsDeleted)

Methods in org.jboss.cache.invocation with parameters of type NodeSPI

void	NodeInvocationDelegate.addChildDirect(NodeSPI<K,V> child)

Uses of NodeSPI in org.jboss.cache.loader

Methods in org.jboss.cache.loader with parameters of type NodeSPI

protected void

SingletonStoreCacheLoader.pushState(NodeSPI node) Pushes the state of a specific node by reading the node's data from the cache and putting in the cache store via the cache loader.

Uses of NodeSPI in org.jboss.cache.lock

Fields in org.jboss.cache.lock declared as NodeSPI

protected NodeSPI

NodeBasedLockManager.rootNode

Methods in org.jboss.cache.lock with parameters of type NodeSPI

static boolean	LockUtil.breakTransactionLock(NodeSPI node, LockManager lockManager, GlobalTransaction gtx, boolean localTx, TransactionTable tx_table, TransactionManager tm)
Collection<Object>	NodeBasedLockManager.getReadOwners(NodeSPI node)
Collection<Object>	LockManager.getReadOwners(NodeSPI node) Retrieves the read lock owners, if any, for the current Fqn.
Object	NodeBasedLockManager.getWriteOwner(NodeSPI node)
Object	LockManager.getWriteOwner(NodeSPI node) Retrieves the write lock owner, if any, for the current Fqn.
boolean	NodeBasedLockManager.isLocked(NodeSPI n)
boolean	LockManager.isLocked(NodeSPI n) Returns true if the node is locked (either for reading or writing) by anyone, and false otherwise.
boolean	NodeBasedLockManager.isLocked(NodeSPI n, LockType type)
boolean	LockManager.isLocked(NodeSPI n, LockType lockType) Returns true if the node is locked (either for reading or writing) by anyone, and false otherwise.
boolean	NodeBasedLockManager.lock(NodeSPI node, LockType lockType, Object owner)
boolean	LockManager.lock(NodeSPI node, LockType lockType, Object owner) As LockManager.lock(org.jboss.cache.Fqn, LockType, Object) except that a NodeSPI is passed in instead of an Fqn.
boolean	NodeBasedLockManager.lock(NodeSPI node, LockType lockType, Object owner, long timeout)
boolean	LockManager.lock(NodeSPI node, LockType lockType, Object owner, long timeout) As LockManager.lock(org.jboss.cache.Fqn, LockType, Object, long) except that a NodeSPI is passed in instead of an Fqn.
boolean	NodeBasedLockManager.lockAll(NodeSPI node, LockType lockType, Object owner)
boolean	LockManager.lockAll(NodeSPI node, LockType lockType, Object owner) Locks the node and all child nodes, acquiring lock of type specified for the owner specified.
boolean	NodeBasedLockManager.lockAll(NodeSPI node, LockType lockType, Object owner, long timeout)
boolean	LockManager.lockAll(NodeSPI node, LockType lockType, Object owner, long timeout) Locks the node and all child nodes, acquiring lock of type specified for the owner specified.
boolean	NodeBasedLockManager.lockAll(NodeSPI node, LockType lockType, Object owner, long timeout, boolean excludeInternalFqns)
boolean	LockManager.lockAll(NodeSPI node, LockType lockType, Object owner, long timeout, boolean excludeInternalFqns) Locks the node and all child nodes, acquiring lock of type specified for the owner specified.
boolean	NodeBasedLockManager.lockAllAndRecord(NodeSPI node, LockType lockType, InvocationContext ctx)
boolean	LockManager.lockAllAndRecord(NodeSPI node, LockType lockType, InvocationContext ctx) Locks the node and all child nodes, acquiring lock of type specified for the owner specified.
boolean	NodeBasedLockManager.lockAndRecord(NodeSPI node, LockType lockType, InvocationContext ctx)
boolean	LockManager.lockAndRecord(NodeSPI node, LockType lockType, InvocationContext ctx) Acquires a lock of type lockType, on a specific Node in the cache, denoted by fqn.
static void	LockUtil.manageReverseRemove(InvocationContext ctx, NodeSPI childNode, boolean reverseRemoveCheck, List createdNodes, CommandsFactory commandsFactory) Test if this node needs to be 'undeleted' reverse the "remove" if the node has been previously removed in the same tx, if this operation is a put()
boolean	NodeBasedLockManager.ownsLock(NodeSPI node, Object owner)
boolean	LockManager.ownsLock(NodeSPI node, Object owner) Tests whether a given owner owns any sort of lock on a particular Fqn.
String	NodeBasedLockManager.printLockInfo(NodeSPI node)
String	LockManager.printLockInfo(NodeSPI node) Prints lock information about a node (and it's children) to a String.
void	NodeBasedLockManager.unlock(NodeSPI node, Object owner)
void	LockManager.unlock(NodeSPI node, Object owner) Releases the lock passed in, held by the specified owner
void	NodeBasedLockManager.unlockAll(NodeSPI node)
void	LockManager.unlockAll(NodeSPI node) Releases locks on a given node and all children for all owners.
void	NodeBasedLockManager.unlockAll(NodeSPI node, Object owner)
void	LockManager.unlockAll(NodeSPI node, Object owner) Releases locks on a given node and all children for a given owner.

Method parameters in org.jboss.cache.lock with type arguments of type NodeSPI

boolean

PessimisticNodeBasedLockManager.lockPessimistically(InvocationContext ctx, Fqn fqn, LockType lockType, boolean createIfNotExists, boolean zeroLockTimeout, boolean acquireWriteLockOnParent, boolean reverseRemoveCheck, List<NodeSPI> createdNodes, boolean skipNotification) Deprecated. A specific lock method for the PessimisticLockInterceptor.

Constructors in org.jboss.cache.lock with parameters of type NodeSPI

IdentityLock(LockStrategyFactory factory, NodeSPI node)
Creates a new IdentityLock using the LockFactory passed in.

Uses of NodeSPI in org.jboss.cache.optimistic

Methods in org.jboss.cache.optimistic that return NodeSPI

NodeSPI<K,V>	WorkspaceNodeImpl.createChild(Object child_name, NodeSPI<K,V> parent, CacheSPI<K,V> cache, DataVersion version)
NodeSPI	WorkspaceNode.createChild(Object child_name, NodeSPI<K,V> parent, CacheSPI<K,V> cache, DataVersion version) Creates a child node.
NodeSPI<K,V>	WorkspaceNodeImpl.getChild(Fqn f)
NodeSPI<K,V>	WorkspaceNode.getChild(Fqn f) Overrides Node.getChild(Fqn) to return a NodeSPI rather than a Node
NodeSPI<K,V>	WorkspaceNodeImpl.getChild(Object childName)
NodeSPI<K,V>	WorkspaceNode.getChild(Object o) Overrides Node.getChild(Object) to return a NodeSPI rather than a Node
NodeSPI<K,V>	WorkspaceNodeImpl.getNode()
NodeSPI<K,V>	WorkspaceNode.getNode() Retrieves a reference to the underlying NodeSPI instance.
NodeSPI<K,V>	WorkspaceNodeImpl.getNodeSPI()

Methods in org.jboss.cache.optimistic with parameters of type NodeSPI

NodeSPI<K,V>	WorkspaceNodeImpl.createChild(Object child_name, NodeSPI<K,V> parent, CacheSPI<K,V> cache, DataVersion version)
NodeSPI	WorkspaceNode.createChild(Object child_name, NodeSPI<K,V> parent, CacheSPI<K,V> cache, DataVersion version) Creates a child node.

Constructors in org.jboss.cache.optimistic with parameters of type NodeSPI

WorkspaceNodeImpl(NodeSPI<K,V> node, TransactionWorkspace workspace)
Constructs with a node and workspace.

Uses of NodeSPI in org.jboss.cache.statetransfer

Methods in org.jboss.cache.statetransfer with parameters of type NodeSPI

protected void	StateTransferManager.acquireLocksForStateTransfer(NodeSPI root, Object lockOwner, long timeout, boolean lockChildren, boolean force) Acquires locks on a root node for an owner for state transfer.
protected void	DefaultStateTransferGenerator.generateNodeDataList(NodeSPI<?,?> node, List<NodeData> list)
protected void	DefaultStateTransferIntegrator.integrateTransientState(ObjectInputStream in, NodeSPI target)
protected void	DefaultStateTransferGenerator.marshallTransientState(NodeSPI node, ObjectOutputStream out) Do a preorder traversal: visit the node first, then the node's children
protected void	StateTransferManager.releaseStateTransferLocks(NodeSPI root, Object lockOwner, boolean childrenLocked) Releases all state transfer locks acquired.