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.
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.