All Classes

Class	Description
AtomicReferenceArrayListAdapter<T>	Wraps an AtomicReferenceArray to implement read-only methods of the List interface.
ByteArrayCharSequence	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.
ByteArrayCharSequence.IncompatibleCharacterException
ByteArrayNodeDefault	Similar to CharArrayNodeDefault but represents each character in UTF-8, instead of Java's default 2-byte UFT-16 encoding.
ByteArrayNodeLeafNullValue	Similar to CharArrayNodeLeafNullValue but represents each character in UTF-8, instead of Java's default 2-byte UFT-16 encoding.
ByteArrayNodeLeafVoidValue	Similar to CharArrayNodeLeafVoidValue but represents each character in UTF-8, instead of Java's default 2-byte UFT-16 encoding.
ByteArrayNodeLeafWithValue	Similar to CharArrayNodeLeafWithValue but represents each character in UTF-8, instead of Java's default 2-byte UFT-16 encoding.
ByteArrayNodeNonLeafNullValue	Similar to CharArrayNodeNonLeafNullValue but represents each character in UTF-8, instead of Java's default 2-byte UFT-16 encoding.
ByteArrayNodeNonLeafVoidValue	Similar to CharArrayNodeNonLeafVoidValue but represents each character in UTF-8, instead of Java's default 2-byte UFT-16 encoding.
CharArrayNodeDefault	A non-optimized implementation of the Node interface.
CharArrayNodeLeafNullValue	Stores only incoming edge as a char[].
CharArrayNodeLeafVoidValue	Stores only incoming edge as a char[].
CharArrayNodeLeafWithValue	Stores only incoming edge as a char[], and a reference to a value.
CharArrayNodeNonLeafNullValue	Stores incoming edge as a char[] and outgoing edges as an AtomicReferenceArray.
CharArrayNodeNonLeafVoidValue	Stores incoming edge as a char[] and outgoing edges as an AtomicReferenceArray.
CharSequenceNodeDefault	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.
CharSequenceNodeLeafNullValue	Stores only incoming edge as a CharSequence (a view onto the original key) rather than copying the edge into a character array.
CharSequenceNodeLeafVoidValue	Stores only incoming edge as a CharSequence (a view onto the original key) rather than copying the edge into a character array.
CharSequenceNodeLeafWithValue	Stores incoming edge as a CharSequence (a view onto the original key) rather than copying the edge into a character array.
CharSequenceNodeNonLeafNullValue	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.
CharSequenceNodeNonLeafVoidValue	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.
CharSequences
ConcurrentInvertedRadixTree<O>	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.
ConcurrentInvertedRadixTree.ConcurrentInvertedRadixTreeImpl<O>
ConcurrentRadixTree<O>	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.
ConcurrentRadixTree.KeyValuePairImpl<O>	Implementation of the KeyValuePair interface.
ConcurrentRadixTree.NodeKeyPair	Encapsulates a node and its associated key.
ConcurrentRadixTree.SearchResult	Encapsulates results of searching the tree for a node for which a given key is a prefix.
ConcurrentRadixTree.SearchResult.Classification
ConcurrentReversedRadixTree<O>	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.
ConcurrentSuffixTree<O>	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.
DefaultByteArrayNodeFactory	A NodeFactory which creates Node objects which store incoming edge characters as a byte array inside the node.
DefaultCharArrayNodeFactory	A NodeFactory which creates various implementations of Node objects all of which store incoming edge characters as a character array inside the node.
DefaultCharSequenceNodeFactory	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.
InvertedRadixTree<O>	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.
Iterables	Provides methods to convert Iterables to Lists and Sets.
KeyValuePair<O>	Encapsulates a key and a value.
LazyIterator<T>	An unmodifiable iterator which computes the next element to return only when it is requested.
LazyIterator.State
LCSubstringSolver	Finds the longest common substring in a collection of documents.
Node	Specifies the methods that nodes must implement.
NodeCharacterComparator	Specifies binary search compatibility, and sorting compatibility, of nodes based on Node.getIncomingEdgeFirstCharacter().
NodeCharacterKey	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.
NodeCharacterProvider	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).
NodeFactory	An interface for a factory which creates new Node objects on demand, to encapsulate specified variables.
NodeUtil	Static utility methods useful when implementing Nodes.
PrettyPrintable	An internal interface implemented by trees, which allows internal details of trees to be accessed by PrettyPrinter.
PrettyPrinter	Utility methods to generate semi-graphical string representations of trees.
RadixTree<O>	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.
ReversedRadixTree<O>	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.
SmartArrayBasedNodeFactory	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.
SuffixTree<O>	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.
VoidValue	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.