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