Namespace VRage.Collections
Classes
CachingDictionary<K, V>
Dictionary wrapper that allows for addition and removal even during enumeration. Done by caching changes and allowing explicit application using Apply* methods.
CachingHashSet<T>
CachingList<T>
List wrapper that allows for addition and removal even during enumeration. Done by caching changes and allowing explicit application using Apply* methods.
ConcurrentCachingHashSet<T>
ConcurrentCachingLinkedList<T>
List wrapper that allows for addition and removal even during enumeration. Done by caching changes and allowing explicit application using Apply* methods.
This version has individual locks for cached and non-cached versions, allowing each to be managed efficiently even across multiple threads
ConcurrentCachingList<T>
List wrapper that allows for addition and removal even during enumeration. Done by caching changes and allowing explicit application using Apply* methods.
This version has individual locks for cached and non-cached versions, allowing each to be managed efficiently even across multiple threads
DictionaryKeysReader<K, V>
DictionaryReader<K, V>
DictionaryValuesReader<K, V>
HashSetReader<T>
HeapItem<K>
ListReader<T>
MyBinaryHeap<K, V>
MyBinaryStructHeap<TKey, TValue>
MyBinaryStructHeap<TKey, TValue>.HeapItem
MyBufferStatistics
MyCommitQueue<T>
Basic copy-on-commit implementation, later it will be faster by using one queue with 2 tails
MyConcurrentArrayBufferPool<TElement>
MyConcurrentArrayBufferPool<TElement>.ArrayAllocator
MyConcurrentBucketPool
MyConcurrentBucketPool<T>
Simple thread-safe pool. Can store external objects by calling return. Creates new instances when empty.
MyConcurrentBucketPool<TElement, TAllocator>
MyConcurrentBufferPool<TElement>
MyConcurrentBufferPool<TElement, TAllocator>
MyConcurrentCollectionPool<TCollection, TItem>
MyConcurrentDictionary<TKey, TValue>
Simple thread-safe queue. Uses spin-lock
MyConcurrentHashSet<T>
Simple thread-safe queue. Uses spin-lock
MyConcurrentList<T>
MyConcurrentPool<T>
Simple thread-safe pool. Can store external objects by calling return. Creates new instances when empty.
MyConcurrentQueue<T>
Simple thread-safe queue. Uses spin-lock
MyDeque<T>
MyDistributedTypeUpdater<T>
Class distributing updates on large amount of objects in configurable intervals. This updater does updates in linear manner in defined steps. Also takes into account type of the item.
MyDistributedTypeUpdater<T>.Enumerator
MyDistributedUpdater<TList, TElement>
Class distributing updates on large amount of objects in configurable intervals.
MyDistributedUpdater<TList, TElement>.Enumerator
MyIntervalList
A set of integer numbers optimized for sets with long consecutive runs. Each interval is stored as two values in m_list: the lower and the upper bound.
For example, the set of numbers 2, 3, 4, 5, 7, 9, 10, 11, 12, 13 (or alternatively in the interval notation <2, 5> U <7, 7> U <9, 13>) is saved as a list { 2, 5, 7, 7, 9, 13 }
MyIntervalList.Enumerator
MyQueue<T>
Allows access to queue by index Otherwise implementation is similar to regular queue
MyQueue<T>.Enumerator
MySinglyLinkedList<V>
MySinglyLinkedList<V>.Enumerator
MySwapQueue
MySwapQueue<T>
Holds three objects in safe manner, use when Reader requires only last valid data. One object is used for reading, one for writing and third is used as buffer, so reader/writer don't have to wait on the other.
MyUniqueList<T>
ObservableCollection<T>
Observable collection that also fix support to clear all. Don't know if ObservableCollection<T> is allocation free.
ObservableCollection<T>.Enumerator
Enumerator which uses index access. Index access on Collection is O(1) operation
QueueReader<T>
SortedDictionaryReader<K, V>
SortedDictionaryValuesReader<K, V>
ThreadSafeStore<TKey, TValue>
TypeSortedCachingList<T>
List wrapper that allows for addition and removal even during enumeration. Done by caching changes and allowing explicit application using Apply* methods.