# Package ghidra.util.datastruct

package ghidra.util.datastruct

- Related Packages
  Package
  Description
  ghidra.util
- 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.
  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.