com.atlassian.clover.util.trie

Class PrefixTree<K,V>

java.lang.Object

com.atlassian.clover.util.trie.PrefixTree<K,V>

Type Parameters:

K - type of the sub-key

V - value to be stored in a leaf

Direct Known Subclasses:

FilePathPrefixTree, PackagePrefixTree

public class PrefixTree<K,V>
extends Object

Implementation of the prefix tree (trie) data structure Trie

Field Summary

Fields

Modifier and Type	Field and Description
protected NodeFactory	nodeFactory
protected Node<K,V>	rootNode

Constructor Summary

Constructors

Constructor and Description
PrefixTree(NodeFactory nodeFactory, K key, V value)
PrefixTree(NodeFactory nodeFactory, Node<K,V> rootNode)

Method Summary

Modifier and Type	Method and Description
void	add(KeySequence<K> keySequence, V value) Adds new value to the trie.
Node<K,V>	find(KeySequence<K> keySequence) Search for a key
Node<K,V>	findNearest(KeySequence<K> keySequence) Search as deep as possible and return the deepest node matching a key sequence.
Node<K,V>	findNearestWithValue(KeySequence<K> keySequence) Search as deep as possible and return the deepest node containing a non-null value matching the keySequence.
Node<K,V>	getRootNode()
void	printTree() Print entire tree to System.out
protected Node<K,V>	rewriteTree(Node<K,V> node, int depth, NodeVisitor<K,V> call) Walk through all the nodes of the prefix tree (including empty intermediate nodes) calling the callback.
Node<K,V>	rewriteTree(Node<K,V> rootNode, NodeVisitor<K,V> call) Walk through all the nodes of the prefix tree (including empty intermediate nodes) calling the callback.
protected void	walkTree(Node<K,V> node, int depth, NodeVisitor<K,V> call) Walk through all the nodes of the prefix tree (including empty intermediate nodes) calling the callback.
void	walkTree(Node<K,V> rootNode, NodeVisitor<K,V> call) Walk through all the nodes of the prefix tree (including empty intermediate nodes) calling the callback.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

rootNode

@NotNull
protected Node<K,V> rootNode

nodeFactory

protected final NodeFactory nodeFactory

Constructor Detail

PrefixTree

public PrefixTree(@NotNull
                  NodeFactory nodeFactory,
                  @NotNull
                  K key,
                  @Nullable
                  V value)

Parameters:

nodeFactory - for creating new nodes

value - value for a root node

PrefixTree

public PrefixTree(@NotNull
                  NodeFactory nodeFactory,
                  @NotNull
                  Node<K,V> rootNode)

Parameters:

nodeFactory - for creating new nodes

rootNode - a root node

Method Detail

add

public void add(@NotNull
                KeySequence<K> keySequence,
                @Nullable
                V value)

Adds new value to the trie. Might replace existing one if key sequence is the same.

Parameters:

keySequence - key

value - value

find

@Nullable
public Node<K,V> find(@NotNull
                                KeySequence<K> keySequence)

Search for a key

Parameters:

keySequence - key

Returns:

Node<K,V> or null if not found

findNearest

@NotNull
public Node<K,V> findNearest(@NotNull
                                      KeySequence<K> keySequence)

Search as deep as possible and return the deepest node matching a key sequence. Warning: this method might return a non-leaf (i.e. the one which was not added via add()), can be useful for setting values in intermediate nodes. Consider using findNearestWithValue() for searching.

Parameters:

keySequence - key

Returns:

Node<K,V>, it can be a root node if not found

findNearestWithValue

@Nullable
public Node<K,V> findNearestWithValue(@NotNull
                                                KeySequence<K> keySequence)

Search as deep as possible and return the deepest node containing a non-null value matching the keySequence.

Parameters:

keySequence - key

Returns:

Node<K,V> with a value found; it can be the root node if key was not found at all and the root node has a value associated with it; or null if no value was not found, even in the root node

getRootNode

@NotNull
public Node<K,V> getRootNode()

printTree

public void printTree()

Print entire tree to System.out

walkTree

public void walkTree(@NotNull
                     Node<K,V> rootNode,
                     @NotNull
                     NodeVisitor<K,V> call)

Walk through all the nodes of the prefix tree (including empty intermediate nodes) calling the callback. Walking is performed IN-ORDER (current node first, next children). It's not specified in which order child nodes will be visited.

Walking assumes that the NodeVisitor will not replace instances of the nodes (i.e. that tree structure does not change while walking).

Parameters:

rootNode - tree root

call - callback method

walkTree

protected void walkTree(@NotNull
                        Node<K,V> node,
                        int depth,
                        @NotNull
                        NodeVisitor<K,V> call)

Walk through all the nodes of the prefix tree (including empty intermediate nodes) calling the callback. Walking is performed IN-ORDER (current node first, next children). It's not specified in which order child nodes will be visited.

Walking assumes that the NodeVisitor will not replace instances of the nodes (i.e. that tree structure does not change while walking).

Parameters:

node - current node

depth - depth in tree of the current node

call - callback method

rewriteTree

public Node<K,V> rewriteTree(@NotNull
                             Node<K,V> rootNode,
                             @NotNull
                             NodeVisitor<K,V> call)

Walk through all the nodes of the prefix tree (including empty intermediate nodes) calling the callback. Walking is performed IN-DEPTH (children first, current node last). It's not specified in which order child nodes will be visited.

Walking assumes that the NodeVisitor may replace instances of the nodes (i.e. that tree structure may change while walking).

Parameters:

rootNode - tree root

call - callback method

Returns:

Node<K, V> new root node

rewriteTree

protected Node<K,V> rewriteTree(@NotNull
                                Node<K,V> node,
                                int depth,
                                @NotNull
                                NodeVisitor<K,V> call)

Walk through all the nodes of the prefix tree (including empty intermediate nodes) calling the callback. Walking is performed IN-DEPTH (children first, current node last). It's not specified in which order child nodes will be visited.

Walking assumes that the NodeVisitor may replace instances of the nodes (i.e. that tree structure may change while walking).

Parameters:

node - current node

depth - depth in tree of the current node

call - callback method

Returns:

Node<K, V> new current node