Click or drag to resize

com.espertech.esper.compat.collections Namespace

[Missing <summary> documentation for "N:com.espertech.esper.compat.collections"]

Classes
  ClassDescription
Public classArrayDequeT
Public classArrayDictionaryTK, TV
Public classArrays
Helper class that assists with operations on arrays.
Public classBaseMapTK, TV
Base for dictionaries that contain extended functionality.
Public classBoundBlockingQueueT
Public classChainedArrayListT
Public classCollectionPlusT
Collection that wraps another collection + an item
Public classCollections
Provides additional functions that are useful when operating on collections.
Public classComparers
Public classComparersCollatingComparer
Public classComparersDefaultComparerT
Public classCompatExtensions
Public classContinuation
Public classCopyOnWriteArraySetT
Public classCopyOnWriteListT
Public classDebugDictionaryK, V
Public classDebugListT
Used to debug calls to a list.
Public classDictionaryExtensions
Public classEmptyDictionaryK, V
Public classEmptyListT
Public classEmptySetT
Public classEnumerationHelper
Collection of utilities specifically to help with enumeration.
Public classFixedDictionaryK, V
Public classFixedDictionarySchemaK
FixedDictionarySchema is a class that represents the structure of a map who's keys are known when the schema is created. FixedSchemas are immutable once they have been created, but because they are known they can be used to create Map objects that have a much smaller memory footprint than conventional hashtables.
Public classGenericExtensions
Public classHashMapTK, TV
An extended dictionary based upon a closed hashing algorithm.
Public classIdentityDictionaryK, V
An extended dictionary based upon a closed hashing algorithm.
Public classImperfectBlockingQueueT
ImperfectBlockingQueue is a blocking queue designed for very high performance exchanges between threads. Multiple readers and writers can exchange information using the ImperfectBlockingQueue. The design allows for a read node and a write node. Both the read node and write node are assumed to be probablistically incorrect at any given time. Specifically, that means that the read node may have actually been processed and the write node may not actually be the tail. Rather than attempting to correct for this imperfection in the data structure, we leverage it.

When a writer attempts to write to the tail, the tail uses an atomic compare-exchange to exchange the next node with the newly allocated node. If the exchange fails, the thread will iterate through the next member until it finds null and the cycle continue again with the atomic compare-exchange. Using this method, the writer will succeed in writing to the tail atomically. The write node does not need to accurately reflect the true end of tail, so adjusting the write node to the written node is "reasonably" accurate.

When a reader attempts to read from the head, an atomic compare exchange is used to test against the "IsProcessed" field of the node. If the node has been processed, then the reader moves on to the next node until it can successfully perform a CAS against the node. If none can be found, the method will force a sleep to simulate a block. Once found, the reader extracts the value for return and sets the head equal to the node just read. Again, since we're probablistic, this is fine. Since we've successfully read from the node, we're assured that all nodes before us have been processed. Being "reasonably" accurate with the read node is fine since the next reader will simply advance from this point.

This class was tested against various concurrent reader/writer models was equal to or outperformed all other models in all cases. However, it still appears that during tight iterations that there is about a 4-1 call ratio between CAS and the Push method which means there is still some efficiency to be squeezed out.

Public classImperfectBlockingQueueTNode
Public classLinkedBlockingQueueT
Public classLinkedHashMapTK, TV
Hashtable and linked list implementation designed to mimic Java's LinkedHashMap functionality.
Public classLinkedHashMapTK, TVEntryEventHandler
Delegate for handling events on dictionary entries.
Public classLinkedHashSetT
Description of LinkedHashSet.
Public classListExtensions
Public classLookaheadEnumeratorT
Public classNoSuchElementException
Public classNullableDictionaryK, V
Public classNullableValueTypeDictionaryK, V
Public classNullEnumerableT
Public classNullEnumeratorT
Public classObjectMap
Public classObsoleteConcurrentDictionaryK, V
Public classOrderedDictionaryTK, TV
Public classPairTFirst, TSecond
General-purpose pair of values of any type. The pair only equals another pair if the objects that form the pair equal, ie. first pair first object equals (.equals) the second pair first object, and the first pair second object equals the second pair second object.
Public classProxyComparerT
Public classProxyEnumerableT
An enumerable that leverages a function.
Public classReadOnlyCollectionT
A wrapper that provide a list that is readonly.
Public classReadOnlyDictionaryTK, TV
A wrapper that provide a dictionary that is readonly.
Public classReadOnlyListT
A wrapper that provide a list that is readonly.
Public classReferenceMapTKey, TValue
Public classReferenceType
Public classSetUtil
Public classSimpleComparerT
Public classSingletonT
Public classStandardComparerT
Public classStringDictionaryV
Public classStringMap
Public classSubListT
Public classSubmapDictionaryK, V
An efficient subsection of an ordered or sorted dictionary. Designed for traversal and lookup, but not necessarily efficient at counting elements.
Public classSynchronizedCollectionT
Public classSynchronizedListT
Public classSynchronizedSetT
Public classTransformCollectionTInt, TExt
Public classTransformDictionaryTK1, TV1, TK2, TV2
Public classTupleTA, TB
Public classTupleTA, TB, TC
Interfaces