All Classes and Interfaces

Class
Description
Wraps an AtomicReferenceArray to implement read-only methods of the List interface.
A CharSequence view onto a byte array of UTF-8-encoded characters, with the proviso that all of the characters were encoded as a single byte in UTF-8.
 
Similar to CharArrayNodeDefault but represents each character in UTF-8, instead of Java's default 2-byte UFT-16 encoding.
Similar to CharArrayNodeLeafNullValue but represents each character in UTF-8, instead of Java's default 2-byte UFT-16 encoding.
Similar to CharArrayNodeLeafVoidValue but represents each character in UTF-8, instead of Java's default 2-byte UFT-16 encoding.
Similar to CharArrayNodeLeafWithValue but represents each character in UTF-8, instead of Java's default 2-byte UFT-16 encoding.
Similar to CharArrayNodeNonLeafNullValue but represents each character in UTF-8, instead of Java's default 2-byte UFT-16 encoding.
Similar to CharArrayNodeNonLeafVoidValue but represents each character in UTF-8, instead of Java's default 2-byte UFT-16 encoding.
A non-optimized implementation of the Node interface.
Stores only incoming edge as a char[].
Stores only incoming edge as a char[].
Stores only incoming edge as a char[], and a reference to a value.
Stores incoming edge as a char[] and outgoing edges as an AtomicReferenceArray.
Stores incoming edge as a char[] and outgoing edges as an AtomicReferenceArray.
A implementation of the Node interface which stores the incoming edge as a CharSequence (a view onto the original key) rather than copying the edge into a character array.
Stores only incoming edge as a CharSequence (a view onto the original key) rather than copying the edge into a character array.
Stores only incoming edge as a CharSequence (a view onto the original key) rather than copying the edge into a character array.
Stores incoming edge as a CharSequence (a view onto the original key) rather than copying the edge into a character array.
Stores incoming edge as a CharSequence (a view onto the original key) rather than copying the edge into a character array, and stores outgoing edges as an AtomicReferenceArray.
Stores incoming edge as a CharSequence (a view onto the original key) rather than copying the edge into a character array, and stores outgoing edges as an AtomicReferenceArray.
 
An implementation of InvertedRadixTree which supports lock-free concurrent reads, and allows items to be added to and to be removed from the tree atomically by background thread(s), without blocking reads.
 
An implementation of RadixTree which supports lock-free concurrent reads, and allows items to be added to and to be removed from the tree atomically by background thread(s), without blocking reads.
Implementation of the KeyValuePair interface.
Encapsulates a node and its associated key.
Encapsulates results of searching the tree for a node for which a given key is a prefix.
 
An implementation of ReversedRadixTree which supports lock-free concurrent reads, and allows items to be added to and to be removed from the tree atomically by background thread(s), without blocking reads.
An implementation of SuffixTree which supports lock-free concurrent reads, and allows items to be added to and to be removed from the tree atomically by background thread(s), without blocking reads.
A NodeFactory which creates Node objects which store incoming edge characters as a byte array inside the node.
A NodeFactory which creates various implementations of Node objects all of which store incoming edge characters as a character array inside the node.
A NodeFactory which creates various implementations of Node objects all of which store incoming edge characters as a CharSequence (a view onto the original key) rather than copying the edge into a character array.
API of an inverted radix tree, that is a radix tree which is set up to scan external documents for keys previously added to the tree, rather than for data contained in the tree itself.
Provides methods to convert Iterables to Lists and Sets.
Encapsulates a key and a value.
An unmodifiable iterator which computes the next element to return only when it is requested.
 
Finds the longest common substring in a collection of documents.
Specifies the methods that nodes must implement.
Specifies binary search compatibility, and sorting compatibility, of nodes based on Node.getIncomingEdgeFirstCharacter().
A lightweight object which simply wraps a Character and implements NodeCharacterProvider, which can be used as a key to locate a node having the same edge first character in a list of nodes using binary search.
A super-interface of both Node and NodeCharacterKey which, by sharing this common interface, enables binary search of nodes via Collections.binarySearch(java.util.List, Object, java.util.Comparator).
An interface for a factory which creates new Node objects on demand, to encapsulate specified variables.
Static utility methods useful when implementing Nodes.
An internal interface implemented by trees, which allows internal details of trees to be accessed by PrettyPrinter.
Utility methods to generate semi-graphical string representations of trees.
API of a radix tree, that is a tree which allows values to be looked up based on prefixes of the keys with which they were associated, as well as based on exact matches for keys.
API of a reversed radix tree, that is a tree which allows values to be looked up based on suffixes of the keys with which they were associated, as well as based on exact matches for keys.
A NodeFactory which internally uses DefaultByteArrayNodeFactory to create nodes by default (which can reduce memory overhead), but falls back to DefaultCharArrayNodeFactory if characters are detected which cannot be represented as a single byte.
API of a generalized suffix tree, that is a tree which allows values to be looked up based on any suffix of the keys with which they were associated, as well as based on exact matches for keys.
A dummy object which if supplied as a value for an entry in a tree, will not actually be stored in the tree by DefaultCharArrayNodeFactory or DefaultCharSequenceNodeFactory to save memory.