Uses of Class
com.bigdata.btree.AbstractNode

Packages that use AbstractNode

com.bigdata.btree

The BTree is a scalable B+-Tree with copy-on-write semantics mapping variable length unsigned byte[] keys to variable length byte[] values (null values are allowed).

Uses of AbstractNode in com.bigdata.btree

Classes in com.bigdata.btree with type parameters of type AbstractNode

class

AbstractNode<T extends AbstractNode> Abstract node supporting incremental persistence and copy-on-write semantics.

Subclasses of AbstractNode in com.bigdata.btree

static class	IndexSegment.ImmutableNodeFactory.ImmutableLeaf Immutable leaf throws UnsupportedOperationException for the public mutator API but does not try to override all low-level mutation behaviors.
static class	IndexSegment.ImmutableNodeFactory.ImmutableNode Immutable node throws UnsupportedOperationException for the public mutator API but does not try to override all low-level mutation behaviors.
class	Leaf A B+-Tree leaf.
class	Node A non-leaf node.

Fields in com.bigdata.btree declared as AbstractNode

protected AbstractNode<?>

AbstractBTree.root The root of the btree.

Fields in com.bigdata.btree with type parameters of type AbstractNode

protected Reference<? extends AbstractNode<T>>

AbstractNode.self A Reference to this Node.

Methods in com.bigdata.btree that return AbstractNode

protected AbstractNode<?>	AbstractNode.copyOnWrite() Return this leaf iff it is dirty (aka mutable) and otherwise return a copy of this leaf.
protected AbstractNode<T>	AbstractNode.copyOnWrite(long triggeredByChildId) Return this node or leaf iff it is dirty (aka mutable) and otherwise return a copy of this node or leaf.
AbstractNode	Node.getChild(int index) Return the child node or leaf at the specified index in this node.
protected AbstractNode	Node.getLeftSibling(AbstractNode child, boolean materialize) Return the left sibling.
AbstractNode	INodeIterator.getNode() The value associated with the last node or leaf visited by Iterator.next().
protected AbstractNode	Node.getRightMostChild(boolean nodesOnly) Return the right-most child of this node.
AbstractNode	AbstractBTree.getRightMostNode(boolean nodesOnly) Utility method returns the right-most node in the B+Tree.
protected AbstractNode	Node.getRightSibling(AbstractNode child, boolean materialize) Return the right sibling of the specified child of a common parent.
protected AbstractNode<?>	AbstractBTree.getRoot() The root of the btree.
protected AbstractNode<?>	AbstractBTree.getRootOrFinger(byte[] key) Returns the node or leaf to be used for search.
protected AbstractNode<?>	IndexSegment.readNodeOrLeaf(long addr) Extended to transparently re-open the backing IndexSegmentStore.
protected AbstractNode<?>	AbstractBTree.readNodeOrLeaf(long addr) Read a node or leaf from the store.
AbstractNode<?>	NodeSerializer.wrap(AbstractBTree btree, long addr, IAbstractNodeData data) Wrap an INodeData or ILeafData instance as a Node or a Leaf.

Methods in com.bigdata.btree that return types with arguments of type AbstractNode

Iterator<AbstractNode>	Node.childIterator(boolean dirtyNodesOnly) Iterator visits the direct child nodes in the external key ordering.
Iterator<AbstractNode>	Node.childIterator(byte[] fromKey, byte[] toKey) Iterator visits the direct child nodes in the external key ordering.
Reference<AbstractNode<?>>	Node.getChildRef(int index) Return the Reference for the child.
Iterator<AbstractNode>	Leaf.postOrderIterator(byte[] fromKey, byte[] toKey) Visits this leaf.
abstract Iterator<AbstractNode>	AbstractNode.postOrderIterator(byte[] fromKey, byte[] toKey) Post-order traversal of nodes and leaves in the tree with a key range constraint.
Iterator<AbstractNode>	Node.postOrderIterator(byte[] fromKey, byte[] toKey) Iterator visits children in the specified half-open key range, recursively expanding each child with a post-order traversal of its children and finally visits this node itself.
Iterator<AbstractNode>	AbstractNode.postOrderNodeIterator()
Iterator<AbstractNode>	IAbstractNode.postOrderNodeIterator() Post-order traveral of nodes and leaves in the tree.
Iterator<AbstractNode>	AbstractNode.postOrderNodeIterator(boolean dirtyNodesOnly) Post-order traversal of nodes and leaves in the tree.
Iterator<AbstractNode>	Leaf.postOrderNodeIterator(boolean dirtyNodesOnly, boolean nodesOnly) Visits this leaf if unless it is not dirty and the flag is true, in which case the returned iterator will not visit anything.
abstract Iterator<AbstractNode>	AbstractNode.postOrderNodeIterator(boolean dirtyNodesOnly, boolean nodesOnly) Post-order traversal of nodes and leaves in the tree.
Iterator<AbstractNode>	Node.postOrderNodeIterator(boolean dirtyNodesOnly, boolean nodesOnly) Iterator visits children, recursively expanding each child with a post-order traversal of its children and finally visits this node itself.

Methods in com.bigdata.btree with parameters of type AbstractNode

protected int	Node.getIndexOf(AbstractNode child) Return the index of the child among the direct children of this node.
protected AbstractNode	Node.getLeftSibling(AbstractNode child, boolean materialize) Return the left sibling.
protected AbstractNode	Node.getRightSibling(AbstractNode child, boolean materialize) Return the right sibling of the specified child of a common parent.
protected void	Node.insertChild(byte[] key, AbstractNode child) Invoked by split() to insert a key and reference for a child created when another child of this node is split.
protected void	Leaf.merge(AbstractNode sibling, boolean isRightSibling) Merge the keys and values from the sibling into this leaf, delete the sibling from the store and remove the sibling from the parent.
protected abstract void	AbstractNode.merge(AbstractNode sibling, boolean isRightSibling) Merge the sibling into this node.
protected void	Node.merge(AbstractNode sibling, boolean isRightSibling) Merge the keys and values from the sibling into this node, delete the sibling from the store and remove the sibling from the parent.
protected void	Leaf.redistributeKeys(AbstractNode sibling, boolean isRightSibling) Redistributes a key from the specified sibling into this leaf in order to bring this leaf up to the minimum #of keys.
protected abstract void	AbstractNode.redistributeKeys(AbstractNode sibling, boolean isRightSibling) Redistribute the one key from the sibling into this node.
protected void	Node.redistributeKeys(AbstractNode sibling, boolean isRightSibling) Redistributes a key from the specified sibling into this node in order to bring this node up to the minimum #of keys.
protected void	Node.removeChild(AbstractNode child) Invoked when a non-root node or leaf has no more keys to detach the child from its parent.
protected void	AbstractBTree.touch(AbstractNode<?> node) This method is responsible for putting the node or leaf onto the ring buffer which controls (a) how long we retain a hard reference to the node or leaf; and (b) for writes, when the node or leaf is evicted with a zero reference count and made persistent (along with all dirty children).
protected void	Node.updateEntryCount(AbstractNode<?> child, long delta) Apply the delta to the per-child count for this node and then recursively ascend up the tree applying the delta to all ancestors of this node.
protected void	Node.updateMinMaxVersionTimestamp(AbstractNode<?> child) Update the Node.getMinimumVersionTimestamp() and Node.getMaximumVersionTimestamp().
protected long	AbstractBTree.writeNodeOrLeaf(AbstractNode<?> node) Codes the node and writes the coded record on the store (non-recursive).
protected void	AbstractBTree.writeNodeRecursive(AbstractNode<?> node) Write a dirty node and its children using a post-order traversal that first writes any dirty leaves and then (recursively) their parent nodes.

Constructors in com.bigdata.btree with parameters of type AbstractNode

AbstractNode(AbstractNode<T> src)
Copy constructor.

Node(BTree btree, AbstractNode oldRoot, long nentries)
This constructor is used when splitting the a root Leaf or a root Node.