Namespace Lucene.Net.Support.C5

Classes

Base class (abstract) for ICollection implementations.

CollectionModifiedException

An exception thrown by enumerators, range views etc. when accessed after the underlying collection has been modified.

CollectionValueBase<T>

Base class for classes implementing ICollectionValue[T]

CollectionValueBase<T>.RaiseForRemoveAllHandler

ConcurrentEnumerationException

An exception thrown by the MemorySafeEnumerator if the collection is enumerated by multiple threads concurrently

DictionaryBase<K, V>

A base class for implementing a dictionary based on a set collection implementation. See the source code for C5.HashDictionary`2 for an example

DirectedCollectionValueBase<T>

An exception thrown when an operation attempts to create a duplicate in a collection with set semantics (C5.IExtensible`1.AllowsDuplicates is false) or attempts to create a duplicate key in a dictionary.

With collections this can only happen with Insert operations on lists, since the Add operations will not try to create duplictes and either ignore the failure or report it in a bool return value.

With dictionaries this can happen with the C5.IDictionary`2.Add(`0,`1) metod.

EnumerableBase<T>

A base class for implementing an IEnumerable<T>

EqualityComparer<T>

Utility class for building default generic equality comparers.

FixedSizeCollectionException

HashDictionary<K, V>

A generic dictionary class based on a hash set class C5.HashSet`1.

HashSet<T>

A set collection class based on linear hashing

IncompatibleViewException

An exception thrown by operations on a list that expects an argument that is a view on the same underlying list.

InternalException

An exception to throw from library code when an internal inconsistency is encountered.

InvalidPriorityQueueHandleException

ItemAtEventArgs<T>

ItemCountEventArgs<T>

KeyValuePairComparer<K, V>

Default comparer for dictionary entries in a sorted dictionary. Entry comparisons only look at keys and uses an externally defined comparer for that.

KeyValuePairEqualityComparer<K, V>

Default equalityComparer for dictionary entries. Operations only look at keys and uses an externally defined equalityComparer for that.

Logger

Logging module

MultipleEnumerationException

An exception thrown by the MemorySafeEnumerator if the collection is enumerated multiple times when the memory mode is set to Strict

NoSuchItemException

An exception thrown by a lookup or lookup with update operation that does not find the lookup item and has no other means to communicate failure.

The typical scenario is a lookup by key in a dictionary with an indexer, see e.g. C5.IDictionary`2.Item(`0)

NotAViewException

An exception thrown by an operation on a list (C5.IList`1) that only makes sense for a view, not for an underlying list.

NotComparableException

An exception thrown by an operation that need to construct a natural comparer for a type.

ReadOnlyCollectionException

An exception thrown by an update operation on a Read-Only collection or dictionary.

This exception will be thrown unconditionally when an update operation (method or set property) is called. No check is made to see if the update operation, if allowed, would actually change the collection.

SequencedBase<T>

Base class (abstract) for sequenced collection implementations.

SequencedCollectionEqualityComparer<T, W>

Prototype for a sequenced equalityComparer for something (T) that implements ISequenced[W]. This will use ISequenced[W] specific implementations of the equality comparer operations.

Showing

SortedDictionaryBase<K, V>

A base class for implementing a sorted dictionary based on a sorted set collection implementation. See the source code for C5.TreeDictionary`2 for an example

TreeDictionary<K, V>

A sorted generic dictionary based on a red-black tree set.

UnlistenableEventException

UnsequencedCollectionEqualityComparer<T, W>

Prototype for an unsequenced equalityComparer for something (T) that implements ICollection[W] This will use ICollection[W] specific implementations of the equalityComparer operations

ViewDisposedException

An exception thrown when trying to access a view (a list view on a C5.IList`1 or a snapshot on a C5.IPersistentSorted`1) that has been invalidated by some earlier operation.

The typical scenario is a view on a list that hash been invalidated by a call to Sort, Reverse or Shuffle on some other, overlapping view or the whole list.

Structs

KeyValuePair<K, V>

An entry in a dictionary from K to V.

Interfaces

ICollection<T>

The simplest interface of a main stream generic collection with lookup, insertion and removal operations.

ICollectionValue<T>

A generic collection that may be enumerated and can answer efficiently how many items it contains. Like

IEnumerable<T>

, this interface does not prescribe any operations to initialize or update the collection. The main usage for this interface is to be the return type of query operations on generic collection.

IDictionary<K, V>

A dictionary with keys of type K and values of type V. Equivalent to a finite partial map from K to V.

IDirectedCollectionValue<T>

A sized generic collection, that can be enumerated backwards.

IDirectedEnumerable<T>

A generic collection, that can be enumerated backwards.

IExtensible<T>

A generic collection to which one may add items. This is just the intersection of the main stream generic collection interfaces and the priority queue interface, C5.ICollection`1 and C5.IPriorityQueue`1.

IIndexed<T>

A sequenced collection, where indices of items in the order are maintained

IIndexedSorted<T>

A collection where items are maintained in sorted order together with their indexes in that order.

IList<T>

This is an indexed collection, where the item order is chosen by the user at insertion time.

NBNBNB: we need a description of the view functionality here!

IPersistentSorted<T>

The type of a sorted collection with persistence

IPriorityQueue<T>

A generic collection of items prioritized by a comparison (order) relation. Supports adding items and reporting or removing extremal elements.

When adding an item, the user may choose to have a handle allocated for this item in the queue. The resulting handle may be used for deleting the item even if not extremal, and for replacing the item. A priority queue typically only holds numeric priorities associated with some objects maintained separately in other collection objects.

IPriorityQueueHandle<T>

The base type of a priority queue handle

IQueue<T>

The interface describing the operations of a FIFO queue data structure.

IReadOnlyCollection<T>

Represents a strongly-typed, read-only collection of elements. Enables System.Collections.Generic.IReadOnlyCollection to be used in .NET 4.5 projects

IReadOnlyList<T>

Represents a read-only collection of elements that can be accessed by index. Enables System.Collections.Generic.IReadOnlyList to be used in .NET 4.5 projects

ISequenced<T>

An editable collection maintaining a definite sequence order of the items.

Implementations of this interface must compute the hash code and equality exactly as prescribed in the method definitions in order to be consistent with other collection classes implementing this interface. This interface is usually implemented by explicit interface implementation, not as ordinary virtual methods.

IShowable

(Describe usage of "L:300" format string.)

ISorted<T>

A sorted collection, i.e. a collection where items are maintained and can be searched for in sorted order. Thus the sequence order is given as a sorting order.

The sorting order is defined by a comparer, an object of type IComparer<T> (C5.IComparer`1). Implementors of this interface will normally let the user define the comparer as an argument to a constructor. Usually there will also be constructors without a comparer argument, in which case the comparer should be the defalt comparer for the item type, C5.Comparer`1.Default.

The comparer of the sorted collection is available as the

System.Collections.Generic.Comparer

property (C5.ISorted`1.Comparer).

The methods are grouped according to

Since this interface extends ISequenced<T>, sorted collections will also have an item equalityComparer (C5.IExtensible`1.EqualityComparer). This equalityComparer will not be used in connection with the inner workings of the sorted collection, but will be used if the sorted collection is used as an item in a collection of unsequenced or sequenced collections, (C5.ICollection`1 and C5.ISequenced`1)

Note that code may check if two sorted collections has the same sorting order by checking if the Comparer properties are equal. This is done a few places in this library for optimization purposes.

ISortedDictionary<K, V>

A dictionary with sorted keys.

IStack<T>

The interface describing the operations of a LIFO stack data structure.

Enums

EnumerationDirection

Direction of enumeration order relative to original collection.

EventTypeEnum

HashSet<T>.Feature

Enum class to assist printing of compilation alternatives.

MemoryType

It specifies the memory type strategy of the internal enumerator implemented to iterate over the collection.

Speed

The symbolic characterization of the speed of lookups for a collection. The values may refer to worst-case, amortized and/or expected asymtotic complexity wrt. the collection size.

Delegates

CollectionChangedHandler<T>

The type of event raised after an operation on a collection has changed its contents. Normally, a multioperation like AddAll, C5.IExtensible`1.AddAll(System.Collections.Generic.IEnumerable{`0}) will only fire one CollectionChanged event. Any operation that changes the collection must fire CollectionChanged as its last event.

CollectionClearedHandler<T>

The type of event raised after the Clear() operation on a collection.

Note: The Clear() operation will not fire ItemsRemoved events.

ItemInsertedHandler<T>

The type of event raised after an item has been inserted into a list by an Insert, InsertFirst or InsertLast operation. The event will be raised at a point of time, where the collection object is in an internally consistent state and before the corresponding CollectionChanged event is raised.

Note: an ItemsAdded event will also be fired.

ItemRemovedAtHandler<T>

The type of event raised after an item has been removed from a list by a RemoveAt(int i) operation (or RemoveFirst(), RemoveLast(), Remove() operation). The event will be raised at a point of time, where the collection object is in an internally consistent state and before the corresponding CollectionChanged event is raised.

Note: an ItemRemoved event will also be fired.

ItemsAddedHandler<T>

The type of event raised after an item has been added to a collection. The event will be raised at a point of time, where the collection object is in an internally consistent state and before the corresponding CollectionChanged event is raised.

Note: an Update operation will fire an ItemsRemoved and an ItemsAdded event.

Note: When an item is inserted into a list (C5.IList`1), both ItemInserted and ItemsAdded events will be fired.

ItemsRemovedHandler<T>

The type of event raised after an item has been removed from a collection. The event will be raised at a point of time, where the collection object is in an internally consistent state and before the corresponding CollectionChanged event is raised.

Note: The Clear() operation will not fire ItemsRemoved events.

Note: an Update operation will fire an ItemsRemoved and an ItemsAdded event.

Note: When an item is removed from a list by the RemoveAt operation, both an ItemsRemoved and an ItemRemovedAt event will be fired.