Package ghidra.util.datastruct

package ghidra.util.datastruct
  • Class
    Description
    AbstractWeakValueMap<K,V>
    Class to provide a map with weak values, backed by a given map
    AbstractWeakValueMap.WeakValueRef<K,V>
    A weak value ref that also knows its key in the map.
    AbstractWeakValueNavigableMap<K,V>
    Class to provide a navigable, e.g., tree-, map with weak values
    AbstractWeakValueNavigableMap.NavigableView<K,V>
    A view of this same map that limits or changes the order of the keys
    Accumulator<T>
    The interface provides a mechanism for clients to pass around an object that is effectively a 'results object', into which data can be placed as it is discovered.
    Array
    Base interface for Defining methods for managing a "virtual" array of some data type.
    BitTree
    The BitTree class maintains a set of ordered keys between the values of 0 and N.
    BooleanArray
    Data structure to set bits to indicate in use.
    ByteArray
    Array of bytes that grows as needed.
    ByteArrayArray
    Array of byte[] that grows as needed.
    CallbackAccumulator<T>
    An implementation of Accumulator that allows clients to easily process items as they arrive.
    CaseInsensitiveDuplicateStringComparator
    Comparator for sorting Strings in a case insensitive way except that case insensitive duplicates are then sub-sorted by reverse case so that lower case is before upper case.
    Counter
    Simple class used to avoid immutable objects and autoboxing when storing changing integer primitives in a collection.
    DataStructureErrorHandlerFactory
    A class data structures can use to delegate error handling responsibilities to system-level decision making.
    DataTable
    Table for managing rows and columns of data.
    DoubleArray
    Array of doubles that grows as needed.
    DoubleArrayArray
    Array of double[] that grows as needed.
    Duo<T>
    Class for holding two objects of the same type.
    Duo.Side
     
    FilteringAccumulatorWrapper<T>
    A class that allows clients to wrap a given accumulator, only adding elements that pass the given filter.
    FixedSizeHashMap<K,V>
    A simple implementation of a LRU map that will throw away entries that exceed the given maximum size.
    FixedSizeStack<E>
    Creates a fixed size stack.
    FloatArray
    Array of floats that grows as needed.
    FloatArrayArray
    Array of float[] that grows as needed.
    FullKeySet
    Implementation of the ShortKeySet interface that always contains all the possible keys.
    IndexRange
    Class for holding a begin and end index.
    IndexRangeIterator
    Iterator interface for index ranges.
    IntArray
    Array of ints that grows as needed.
    IntArrayArray
    Array of int[] that grows as needed.
    IntArrayList
    An ArrayList type object for ints.
    IntIndexManager
    Class to generate int indexes to be used for arrays or tables.
    IntIntHashtable
    Class that implements a hashtable with int keys and int values.
    IntKeyIndexer
    This class converts arbitrary int keys into compacted int indexes suitable for use as indexes into an array or table.
    IntListIndexer
    Class to manage multiple linked lists of int indexes.
    IntObjectHashtable<T>
    Class that implements a hashtable with int keys and Object values.
    IntSet
    Class for storing a set of integers
    ListAccumulator<T>
     
    ListenerErrorHandler
    A simple interface that allows listener structures to use different error handling
    ListenerErrorHandlerFactory
    A simple interface for creating listener error handlers
    ListenerSet<T>
    A data structure meant to be used to hold listeners.
    LongArray
    Array of longs that grows as needed.
    LongArrayArray
    Array of long[] that grows as needed.
    LongArrayList
    An ArrayList for longs.
    LongComparator
    Interface that defines a method for comparing two long values.
    LongDoubleHashtable
    Class that implements a hashtable with long keys and double values.
    LongIntHashtable
    Class that implements a hashtable with long keys and int values.
    LongKeyIndexer
    This class converts arbitrary long keys into compacted int indexes suitable for use as indexes into an array or table.
    LongLongHashtable
    Class that implements a hashtable with long keys and long values.
    LongObjectHashtable<T>
    Class that implements a hashtable with long keys and Object values.
    LRUMap<K,V>
    A LRU (Least Recently Used) map that maintains access-order (newest to oldest) iteration over the elements.
    LRUSet<T>
    An ordered set-like data structure.
    ManagedDataTable
    Data table that keeps track of rows that are occupied.
    NoSuchIndexException
    Exception thrown if a requested index does not exist.
    ObjectArray
    Array of objects that grows as needed.
    ObjectCache
    ObjectClass provides a fixed-size long-key-based object cache.
    ObjectIntHashtable<T>
    Class that implements a hashtable with Object keys and int values.
    ObjectKeyIndexer<T>
    This class converts arbitrary Objects into compacted int indexes suitable for use as indexes into an array or table.
    ObjectLongHashtable<T>
    Class that implements a hashtable with Object keys and long values.
    ObjectRangeMap<T>
    Associates objects with long index ranges.
    ObjectValueRange<T>
    Associates an integer value with a numeric range.
    Prime
    Class that provides a static nextPrime method that gives out prime numbers that are useful in a buffer doubling strategy with all buffer sizes being prime.
    PriorityQueue<T>
    Maintains a list of objects in priority order where priority is just an integer value.
    PropertySetIndexRangeIterator
    Iterator over Property Set Index ranges that have the same value
    QueueStub<E>
    A do-nothing, stubbed version of the Queue interface.
    Range
    A class for holding a minimum and maximum signed int values that define a range.
    RangeMap
    Stores ranges of int values throughout "long" space.
    RedBlackEntry<K,V>
     
    RedBlackKeySet
    A RedBlack Tree implementation of the ShortKeySet interface.
    RedBlackLongKeySet
    A RedBlack Tree implementation of a long key set.
    RedBlackTree<K extends Comparable<K>,V>
    A RedBlack Tree implementation with K type keys and place to store V type values.
    SetAccumulator<T>
     
    ShortArray
    Array of shorts that grows as needed.
    ShortArrayArray
    Array of byte[] that grows as needed.
    ShortKeyIndexer
    This class converts arbitrary short keys into compacted short indexes suitable for use as indexes into an array or table.
    ShortKeySet
    The ShortKeySet provides an interface for managing a set of ordered short keys between the values of 0 and N.
    ShortListIndexer
    Class to manage multiple linked lists of short indexes.
    ShortLongHashtable
    Class that implements a hashtable with Short keys and long values.
    ShortObjectHashtable
    Class that implements a hashtable with short keys and Object values.
    ShortStringHashtable
    Class that implements a hashtable with short keys and String values.
    SizeLimitedAccumulatorWrapper<T>
     
    SoftCacheMap<K,V>
    Class to manage a "soft" HaspMap that keeps its keys as soft references so they can be reclaimed if needed.
    SortedRangeList
    Provides a list of integer ranges that are maintained in sorted order.
    Stack<E>
    The Stack class represents a last-in-first-out (LIFO) stack of objects.
    StringArray
    Array of Strings that grows as needed.
    StringArrayArray
    Array of String[] that grows as needed.
    StringIntHashtable
    Class that implements a hashtable with String keys and int values.
    StringKeyIndexer
    This class converts arbitrary Strings into compacted int indexes suitable for use as indexes into an array or table.
    SynchronizedListAccumulator<T>
     
    ValueRange
    Associates an integer value with a numeric range.
    WeakDataStructureFactory
    Factory for creating containers to use in various threading environments Other non-weak listeners: ConcurrentListenerSet
    WeakSet<T>
     
    WeakStore<T>
    Class for storing a weak reference to object instances.
    WeakValueHashMap<K,V>
    Class to provide a hash map with weak values.
    WeakValueTreeMap<K,V>
    Class to provide a tree map with weak values.