| Class | Description | |
|---|---|---|
 | NAccumulatingVisitor | The NAccumulatingVisitor class is used to accumulate the visited graph parts |
| NAndFilter<T> | A composite filter, which represents a boolean algebra AND expression between the contained filters |
| NArrayHelpers<T> | Provides helper methods for working with generic arrays |
| NArrayIterator<T> | Represents a forward iterator, that can be initialized to iterate through an entire array or only a range of the it. |
| NArrayReverseIterator<T> | Represents a reverse iterator, that can be initialized to iterate through an entire indexed set or only a range of the it. |
| NAsFilter<T,TTargetType> | Filters items that are instances of the TTargetType generic argument and pass a specific inner filter. |
| NAsIterator<TFrom,TTo> | An iterator, which aggregates another iterator and casts it output to the specified type. |
| NBicomp | Decomposes a graph into its biconnected components and builds it block-cut tree, in which each node is a cut vertex or a biconnected component. |
| NBitMatrix | Represents a 2D array of boolean values which is similar to a 2D bool array with the exception that each value uses 1 bit instead of 1 byte. |
| NBlocksDeque<T> | Represents an implementation of the INDeque interface, that is based on fixed size array blocks organized in a ring. |
| NBlocksQueue<T> | Represents an INQueue implementation, that is based on fixed size array blocks organized in a ring. |
| NBlocksRing<T> | Serves as base class for blocks ring based implementations of INDeque and INQueue. |
| NBlocksStack<T> | Represents an INStack implementation, that is based on fixed size array blocks organized in a ring. |
| NChain<T> | Represents a doubly-linked linear list, that implements the INCollection and INDeque interfaces for manipulating its nodes. The items of a chain are instances of the NChainNode type, which on its turn holds an Item from the generic type argument (datum). |
| NChainList<T> | Represents the items of a chain. Modifications that you make to items reflect on the chain nodes. Unlike the NChain that focuses on the nodes in the chain, the NChainItems focuses on the items contained in the chain nodes. Implements the INList and INDeque interfaces. |
| NChainNode<T> | Represents a node from a chain (doubly linked linear list). |
| NCLRAdapt<T> | Provides helper methods for adapting NOV Data Structures interfaces to .NET Common Language Runtime (CLR) interfaces and vice versa. |
| NComparisonFilter<T> | Provides facility methods for creating filters that provide different comparision operators, such as Equals, LessThan, GreaterThan, LessThanOrEqual and GreaterThanOrEqual. |
| NCompositeComparer<T> | Represents a comparer that defines an order based on a set of other comparer. It compares the values with the first comparer first, if the values are not equal it uses the comparison as result, otherwise it uses the next comparer in the list. |
| NCountingVisitor | The NCountingVisitor is used to count the visited graph parts |
| NDeque<T> | Represents an INDeque implementation, that is based on an array ring. |
| NDynamicArray<T> | Serves as base class for different INSet implementations that are based on a zero based array of generic items. |
| NDynamicArrayRing<T> | Serves as base class for array ring based implementations of INDeque and INQueue. Implements the INArray and INClearable interfaces. |
| NEmptyIterator<T> | An iterator which is always at the end (e.g. ended). You cannot create instances of this class, and you must always use the Instance singleton. |
| NEqualsToFilter<T> | A filter that returns true if the item is equal to another item. The equality is checked with the Compare method. |
| NFalseFilter<T> | A constant FALSE filter. You cannot create instances of this type and must always use the Instance singleton. |
| NFilter<T> | A filter that uses a delegate function to filter items. |
| NFilterIterator<T> | An iterator, which aggregates another iterator and filters its output |
| NGraph | The NGraph class represents a graph |
| NGraphAdapter | The NGraphAdapter class is used to abstract users from the actual way in which the specified objects form graphs. |
| NGraphBuilder | The NGraphBuilder class is used for the construction of a graph, which represents a single or multiple connected object regions. |
| NGraphEdge | The NGraphEdge class represents an edge connecting two vertices |
| NGraphEdgeList | The NGraphEdgeList class represents a typed list of NGraphEdge instances |
| NGraphPart | The NGraphPart class servers as base class for graph edges, graph vertices, tree edges and tree vertices |
| NGraphPartContainer | The NGraphPartContainer class serves as base class for graphs and trees. |
| NGraphPartFactory | The NGraphPartFactory class is used by the graph builder for the actual construction of graph parts |
| NGraphPartVisitor | The NGraphPartVisitor class is used to visit the parts of graphs and trees and serves as base class for all types of graph part visitors |
| NGraphVertex | The NGraphVertex class represents a vertex in a graph |
| NGraphVertexDegreeComparer | The NGraphVertexDegreeComparer class implements the IComparer interface and compares graph vertices by their degree |
| NGraphVertexList | The NGraphVertexList class represents a typed list of NGraphVertex instances. |
| NGreaterThanFilter<T> | A filter that returns true, if the item is GreaterThan to another item. Checked with the CompareTo method. |
| NGreaterThanOrEqualToFilter<T> | A filter that returns true, if the item is GreaterThanOrEqualTo to another item. Checked with the CompareTo method. |
| NIndexedSetIterator<T> | Represents a forward iterator, that can be initialized to iterate through an entire indexed set or only a range of the it. |
| NIndexedSetReverseIterator<T> | Represents a reverse iterator, that can be initialized to iterate through an entire set or only a range of the it. |
| NIsFilter<T,TTargetType> | Filters objects that are instances of the specified type. You cannot create instances of this type and must always use the Instance singleton. |
| NIteratorHelpers<T> | Provides helper methods for working with iterators |
| NKeyInstanceCache<TKey,TValue> | Serves as base class for cache objects that cache object instances constructed for keys. The NKeyInstanceCache is typically used when you have an expensive to construct object, that is used to maintain readonly informaiton, such as a Nevron.Editors.NDesigner. Internally implemented as a MRU cache. |
| NLessThanFilter<T> | A filter that returns true, if the item is LessThan to another item. Checked with the CompareTo method. |
| NLessThanOrEqualToFilter<T> | A filter that returns true, if the item is LessThanOrEqualTo to another item. Checked with the CompareTo method. |
| NList<T> | Represents an INList implementation that is based on a zero-based array (i.e. Array List). Also implements the INDeque interface. |
| NMap<TKey,TValue> | Represents an INMap implementation, that is based on a Prime Hash Table (i.e. Hash Map). |
| NNotFilter<T> | Represents a boolean algebra NOT expression and is used to invert the result of the filter it contains |
| NObjectEqualsFilter<T> | A filter objects that are object equal to another object. Uses the Object.Equals method. |
| NObjectGraphPartMap | The NObjectGraphPartMap class, represents a mapping between a logical object and a graph part. An instance of this class is produced by graph and tree builders. |
| NOrFilter<T> | A composite filter, which represents a boolean algebra OR expression between the contained filters |
| NQueue<T> | Represents an INQueue implementation, that is based on an array ring. |
| NReadonlyArray<T> | Represents a readonly array of items. |
| NReferenceEqualsFilter<T> | Filters objects, which are equal by reference with the specified object. Uses the Object.ReferenceEquals method. |
| NReverseComparer<T> | Represents a comparer that reverses the order defined by its inner comparer. |
| NSnapshotIterator<T> | An iterator, which makes a snapshot of the items provided by another iterator, that it later provides to this iterator consumers. |
| NStack<T> | Represents an INStack implementation that is based on a zero based array. |
| NStringMap<T> | Represents a map like structure of string-value pairs that provides some advanced string search routines for the keys. This comes at the cost that the access by key is not O(1) as in a hash table based map, but O(log N). |
| NStringSet | Represents a set of strings that provides some advanced string search routines. |
| NStringSimilarityContext | This class contains settings that control the string matching policy used in some string search algorithms. |
| NTreeGraph | Represents a tree graph |
| NTreeGraphEdge | Represents an edge connecting two tree vertices |
| NTreeGraphEdgeList | The NTreeEdgeList class represents a typed list of NTreeEdge instances |
| NTreeGraphVertex | The NTreeVertex class represents a vertex in a tree (tree item) |
| NTreeGraphVertexList | The NTreeVertexList class represents a typed list of NTreeVertex instances |
| NTrueFilter<T> | A constant TRUE filter. You cannot create instances of this type and must always use the Instance singleton. |
| NTypeEqualsFilter<T,TTargetType> | Filter objects of type T, the type of which exactly matches TTargetType. You cannot create instances of this type and must always use the Instance singleton. |
| NUniqueSet<T> | Represents an INDynamicSet implementation, that contains only unique items (i.e. has no duplicate items). It is based on a Prime Hash Table. |
Nevron.Nov.DataStructures Namespace
In This Topic
Classes
Interfaces
| Interface | Description | |
|---|---|---|
 | INAddable<T> | Implemented by objects in which you can add items from a specific type. |
| INArray<T> | Combines the features of INIndexedMultiSet and INWritableIndexedSet |
| INClearable | Implemented by objects from which you can remove all content (items). |
| INCollection<T> | Represents a dynamic, writable array set, in which you can also insert and remove items at arbitrary indices. |
| INContains<T> | Implemented by objects that can be threated as finite or infinite sets of specific items. |
| INCountable<T> | Implemented by objects that can provide a count for a specific type of items. |
| INDeque<T> | Represents a finite set, with double-ended queue access (provides access and modifications to both its head and tail). |
| INDynamicSet<T> | Represents a finite set, in which you can add new items and remove existing ones. |
| INFilter<T> | Represents a filter for objects of a certain type. |
| INGreaterThanComparer<T> | |
| INIndexedMultiSet<T> | Represents an indexed set, in which certain items can possibly appear more than once. |
| INIndexedSet<T> | Represents a finite set, with support for random access read at arbitrary indices. |
| INIterable<T> | Implemented by objects that can provide forward iterators (i.e. support sequential access in first-to-last order). |
| INIterator<T> | Represents an interator, which exposes sequential access to a set of items of the specified type |
| INList<T> | Represents a collection in which items can appear multiple times. |
| INMap<TKey,TValue> | Represents a dynamic set of key-value pairs, where each key is unique for the set. |
| INQueue<T> | Represents a finite set, with FIFO (First-In First-Out) items access. |
| INRemovable<T> | Implemented by objects from which you can remove items from a specific type. |
| INReverseIterable<T> | Implemented by objects that can provide reverse iterators (i.e. support sequential access in last-to-first order). |
| INSet<T> | Represents a fininite set of items. |
| INStack<T> | Represents a finite set, with LIFO (Last-In First-Out) items access. |
| INWritableIndexedSet<T> | Represents an indexed set, with support for random access write (set item at arbitrary index) |
Enumerations
| Enumeration | Description | |
|---|---|---|
 | ENGraphPartType | Enumerates the possible graph part types |
| ENGraphType | Enumerates the possible graph types. |
| ENSetOperator | Represents a boolen set operation between sets. |
| ENStringMatchMode | Enumerates the supported string match modes used by string maps. |
See Also