Abstract base class that simplifies the implementation of IContextLookupChainLink.

An abstract base implementation of IUndoUnit.

Utility class that implements the ILookup interface by delegating to a LookupCallback method.

An IEnumerable<(Of <(<'T>)>)> that casts items.

A wrapping implementation of an IEnumerator<(Of <(<'T>)>)> that casts elements from a given non-generic enumerator to another one.

A wrapping implementation of an IEnumerator<(Of <(<'T>)>)> that upcasts elements from a given enumerator to another one.

A ICollectionModel<(Of <(<'T>)>)> implementation that is the composite of two models of the same type.

A ICollectionModel<(Of <(<'T>)>)> implementation that is the composite of two models.

A composite enumerable that enumerates two given enumerables one after the other.

A composite enumerator that enumerates two given enumerators one after the other.

A generic support class that can manage IUndoUnit instances to support undoability.

A convenience implementation of the IUndoUnit interface that uses simple delegates for the actual undo and redo operations.

A simple mutable ILookup implementation that is backed by a dictionary.

A utility class that implements an immutable always empty ICollection<(Of <(<'T>)>)>.

A utility class that implements an immutable always empty IEnumerable<(Of <(<'T>)>)>.

A utility class that implements an always empty IEnumerator<(Of <(<'T>)>)>.

A utility class that implements an immutable always empty ICollection<(Of <(<'T>)>)>.

A utility class that implements an immutable always empty IListEnumerable<(Of <(<'T>)>)>.

An event "filter" implementation that can be used to collapse events within a given time span and fire a final event after the time has elapsed.

A collection model that filters items from the underlying collection given a predicate function.

An IEnumerable<(Of <(<'T>)>)> implementation that applies a Predicate<(Of <(<'T>)>)> to determine which elements to yield in the enumeration.

An IEnumerator<(Of <(<'T>)>)> implementation that applies a Predicate<(Of <(<'T>)>)> to filter a backing enumerator.

A helper holder class that can contain a Value of a specific type.

This is a utility class that makes it possible to call a parameterized method with 1,2, or 3 arguments specifying the type parameters at runtime.

The cell class that constitutes GenericYList<(Of <(<'T>)>)>s.

A generic linked list implementation.

An ICollection<(Of <(<'T>)>)> that obeys the 'set' semantics.

A subclass of ItemEventArgs<(Of <(<'T>)>)> that stores a typed Item and that can be marked as Handled.

An implementation of a chain of IContextLookupChainLinks.

Static utility class that servers as a factory for various ILookup implementations and provides static utility methods that simplify the usage of Lookup(Type) calls.

An ICompoundEdit implementation that uses IMementoSupport to track changes on a set of items.

A simple IUndoUnit implementation that uses a IMementoSupport to track, undo, and redo state changes on a given subject.

An enumerable that enumerates a single item, only.

An enumerator that enumerates a single item, only.

A lightweight collection that contains exactly one single item.

A lightweight list that contains exactly one single item.

A state for use in a StateMachine

A state machine implementation that can be used to manage complex state and transitions.

A casting IMapper<(Of <(<'K, V>)>)> implementation that uses the ITagOwner implementation of the IModelItem.

A transition for use in a StateMachine.

A utility class that can be used as a key in dictionary like use cases to provide type-safe values.

A specialized IMapper<(Of <(<'K, V>)>)>-like implementation that uses TypedKey<(Of <(<'T>)>)>s as the keys and their corresponding strongly typed values as the values.

A generic support class that can manage IUndoUnit instances to support undoability.

A simple struct that holds a tuple consisting of an implementation of IMementoSupport, an object instance and its state memento.

The interface used by IUndoSupport's and UndoEngine's BeginCompoundEdit(String, String) implementation.

An interface for instances that can provide a ILookup capabilities for a given object.

An interface for instances that can be used to chain lookup operations.

The basic lookup interface that allows for retrieving implementations for different aspects of the current instance.

Interface that can be used to decorate the lookup result for a set of types.

An interface for instances that can provide an ILookup implementation for a given object.

Utility interface that can be used in conjunction with MementoUndoUnit to create IUndoUnit implementations.

Interface implemented by items that can be tagged with arbitrary objects.

Interface that is mostly used in Lookup(Type) for entities that support undoability.

Implements a unit that can be undone and redone.

The delegate that is used by DelegateUndoUnit<(Of <(<'T>)>)>.

A generic factory method delegate that creates instances of a given type and takes a context object of a given type.

Callback delegate that can be used to query results of a virtual Lookup(Type) call on objects that don't necessarily implement ILookup.

Callback method that will be called when a State has been entered in a StateMachine.

Callback method that will be called when a State has been exited in a StateMachine.

Callback that is used by StateCreated and StateRemoved

Callback method that will be called when a Transition has been traversed in a StateMachine.

Callback that is used by TransitionCreated and TransitionRemoved