Module list 

The list side of DynamicData (DynamicData/List): changes of positions in a list, their change sets, and the lists that produce them.

The types keep upstream’s names (Change<T>, ChangeSet<T>, IChangeSet<T>), which in .NET differ from those of the cache side by their number of type parameters; here they are told apart by their module, and the crate root re-exports those of the cache.

Modules

testing

The aids for tests that DynamicData ships with the library (List/Tests, namespace DynamicData.Tests): ChangeSetAggregator<TObject>.

Structs

Change

A change of a list (Change<T>): of one item, or of a range of items.

ChangeAwareList

A list that records its changes until they are captured (ChangeAwareList<T>), batching consecutive insertions and removals into ranges as upstream does.

ChangeSet

The changes of one edit of a list (ChangeSet<T>): shared and immutable, as the change sets of caches are.

Group

A group of the items of a list that share a group key (Group<TObject, TGroup>, the IGroup of the change sets of GroupOn): the grouping edits its list, and its observers watch it. A clone is the same group.

ImmutableGroup

The state of a group of a list at one moment (ImmutableGroup<TObject, TGroupKey>, the IGrouping of the change sets of GroupWithImmutableState): a copy of its items. A clone is the same state.

ItemChange

The change of one item of a list (ItemChange<T>).

ObservableList

A read-only list of the items of a sequence of change sets (AnonymousObservableList<T>, the result of AsObservableList).

PageChangeSet

The changes of a page of a list, and the page (PageChangeSet<T>).

RangeChange

The items of a change of a range, and the index of the first (RangeChange<T>).

SortException

The error of a sort that cannot find the position of an item (SortException): a comparer that does not give a unique position to each item while a binary search is asked for, or an item that is not in the sorted collection. The operators end their sequence with it, as an exception thrown in an operator of upstream reaches OnError.

SourceList

The source of a reactive list (SourceList<T>): edits make change sets, which connect delivers to the operators.

VirtualChangeSet

The changes of a window of a list, and the window (VirtualChangeSet<T>).

Enums

ChangeType

Whether a change is of one item or of a range (ChangeType).

ListChangeReason

The reason of a change of a list (ListChangeReason).

ListFilterPolicy

How a dynamic filter of a list applies a new predicate (ListFilterPolicy).

SortOptions

The options of the sort of a list (SortOptions).

Traits

FlattenBufferResultListEx

flatten_buffer_result as a method of the sequences of buffers of change sets of lists.

IChangeSet

A change set of a list, of any form (IChangeSet<T>): the plain one, and the paged and virtual ones, which hold a plain one with more parts.

IChangeSetAdaptor

Applies the change sets of a list to something else, such as a collection (IChangeSetAdaptor<T>).

IExtendedList

A list with the range operations of DynamicData (IExtendedList<T>, an IList<T>).

IGroup

A group of the items of a list that share a group key, with the list of those items (IGroup<TObject, TGroup>): the items of the change sets of GroupOn and GroupOnProperty.

IGrouping

The state of a group of a list at one moment (IGrouping<TObject, TGroupKey>): the items of the change sets of GroupWithImmutableState and GroupOnPropertyWithImmutableState.

IList

A list that the changes of a list can be applied to (System.Collections.Generic.IList<T>, with the forms of ListEx as provided methods).

IObservableList

A list that can be observed (IObservableList<T>).

IPageChangeSet

A change set of a page of a list, with the description of the page (IPageChangeSet<T>).

ISourceList

A list whose items are edited by its owner (ISourceList<T>).

IVirtualChangeSet

A change set of a window of a list, with the description of the window (IVirtualChangeSet<T>).

ListChangeSetSource

A source of the change sets of a list: a sequence of change sets, or a list whose Connect() is its sequence (the items of upstream’s collections of sources).

ListChangeSetSourcesEx

MergeChangeSets of an enumerable of sequences of change sets of lists (MergeChangeSets(this IEnumerable<IObservable<IChangeSet<TObject>>>, ..)): the sequences are enumerated when the merge is subscribed, and the merge completes after them unless completable is false.

ListSourceListCombineEx

And, Or, Xor and Except of an observable list of sources (And(this IObservableList<IObservable<IChangeSet<T>>>), And(this IObservableList<IObservableList<T>>), And(this IObservableList<ISourceList<T>>), ..): the result follows the sources as they are added to the list and removed from it.

ListSourcesCombineEx

And, Or, Xor and Except of a collection of sources (And(this ICollection<IObservable<IChangeSet<T>>>), ..): the sources are subscribed in order when the result is subscribed.

ObservableListChangeSetsEx

MergeChangeSets of a sequence of sequences of change sets of lists (MergeChangeSets(this IObservable<IObservable<IChangeSet<TObject>>>, IEqualityComparer< TObject>? = null)).

ObservableListEx

The operators of lists (ObservableListEx).

ObservableObjectListEx

The operator of the sequences of change sets of lists of objects (Rc<dyn Any>, whose items have no equality, so that ObservableListEx does not apply to them).

SourceListEditConvenienceEx

The edit conveniences of source lists (SourceListEditConvenienceEx), implemented for every source list.

SourceListEx

The operators of lists (SourceListEx, and the extension methods of ObservableListEx on IObservableList and ISourceList).

SwitchListEx

Switch of a sequence of lists or of sequences of change sets.

Functions

binary_search_by

The index of value by a comparison, or the bitwise complement of where it belongs (ListEx.BinarySearch): Err(index) for the latter.

clear_or_remove_many

Removes the items of the change, or clears the list when they are all of it (ListEx.ClearOrRemoveMany).

clone_changes

Applies the changes to target (ListEx.Clone(IList<T>, IChangeSet<T>)).

clone_changes_with

Applies the changes to target, comparing items with comparer (ListEx.Clone(IList<T>, IEnumerable<Change<T>>, IEqualityComparer<T>)).

flatten

The changes of the change set as changes of one item each (Flatten, ItemChangeEnumerator): an added range becomes additions and a removed range or a clear removals, numbered from the index of the range, or from the last index known when the range has none.

flatten_buffer_result

The buffers of change sets, each as one change set; the empty buffers are left out (FlattenBufferResult(IObservable<IList<IChangeSet<T>>>)).

remove_many

Removes the items (ListEx.RemoveMany): by their indexes from the last, unless an item is there more than once, when each is removed by a search.

replace

Replaces original with replace_with (ListEx.Replace).

replace_or_add

Replaces original with replace_with, or adds it when original is not in the list (ListEx.ReplaceOrAdd).

transform_change_set

The change set with each item converted by transformer; the reasons and indexes stay (Transform(IChangeSet<TSource>, Func<TSource, TDestination>)).

yield_without_index

The changes without their indexes; moves, which make no sense without them, are left out (YieldWithoutIndex, WithoutIndexEnumerator).