Namespace Stride.Core.Collections
Classes
- ConstrainedList<T>
Represent a collection associated with a constraint. When an item is added to this collection, it is tested against the constraint. If the test fails, the item can either be discarded, or an exception can be thrown. The desired behavior can be defined with ThrowException.
- FastCollection<T>
Faster and lighter implementation of Collection<T> with value types enumerators to avoid allocation in foreach loops, and various helper functions.
- FastList<T>
Similar to List<T>, with direct access to underlying array.
- FastTrackingCollection<T>
Represents a collection that generates events when items get added or removed.
- IndexingDictionary<T>
A dictionary that maps index values to items. It uses a sparse list internally for storage.
- KeyedSortedList<TKey, T>
List of items, stored sequentially and sorted by an implicit invariant key that are extracted from items by implementing GetKeyForItem(T).
- MultiValueSortedDictionary<TKey, TValue>
Represents a priority queue, where keys are sorted and each key might have mlutiple values.
- MultiValueSortedDictionary<TKey, TValue>.ValueCollection
Represents the collection of values in a KoderHack.MultiValueSortedDictionary<TKey,TValue>. This class cannot be inherited
- MultiValueSortedList<TKey, TValue>
Represents a priority queue, where keys are sorted and each key might have mlutiple values.
- OrderedCollection<T>
A collection that maintains the order of the elements and lightter implementation of Collection<T> with value types enumerators to avoid allocation in foreach loops, and various helper functions.
- PriorityNodeQueue<T>
Implements a priority queue of type T.
Elements may be added to the queue in any order, but when we pull elements out of the queue, they will be returned in 'ascending' order. Adding new elements into the queue may be done at any time, so this is useful to implement a dynamically growing and shrinking queue. Both adding an element and removing the first element are log(N) operations.
The queue is implemented using a priority-heap data structure. For more details on this elegant and simple data structure see "Programming Pearls" in our library. The tree is implemented atop a list, where 2N and 2N+1 are the child nodes of node N. The tree is balanced and left-aligned so there are no 'holes' in this list.
- PriorityQueueNode<T>
Represents a node in a priority queue, to allow O(n) removal.
- PriorityQueue<T>
Represents a sorted queue, with logarithmic time insertion and deletion.
- ReadOnlySet<T>
Represents a strongly-typed, read-only set of element.
- SafeList<T>
A list to ensure that all items are not null.
- SortedList<TKey, TValue>
Represents a collection of associated keys and values that are sorted by the keys and are accessible by key and by index.
- TrackingCollection<T>
Represents a collection that generates events when items get added or removed.
- TrackingDictionary<TKey, TValue>
Represents a dictionary of key/value pairs that generates events when items get added or removed.
- TrackingHashSet<T>
Represents a hash set that generates events when items get added or removed.
Structs
- MultiValueSortedDictionary<TKey, TValue>.Enumerator
Enumerates the elements of a KoderHack.MultiValueSortedDictionary<TKey,TValue>.
- MultiValueSortedDictionary<TKey, TValue>.ValueCollection.Enumerator
Enumerates the elements of a KoderHack.MultiValueSortedDictionary<TKey,TValue>.ValueCollection.
- PoolListStruct<T>
A pool of objects allocated and can be cleared without losing previously allocated instance.
Interfaces
- IReadOnlySet<T>
Represents a strongly-typed, read-only set of element.