Files
spark/src/client/spark_core/utils/CollectionHelper.cs
T

379 lines
16 KiB
C#

using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.Linq;
namespace bts.utils {
static class CollectionHelper {
public const string indexer_name = "Item[]";
public static int binary_search<T>(IList<T> items, T value, IComparer<T> comparer) =>
binary_search(items, value, 0, items.Count, comparer);
public static int binary_search<T>(IList<T> items, T value, int index, int length, IComparer<T> comparer) {
if (comparer == null) comparer = Comparer<T>.Default;
int lo = index;
int hi = index + length - 1;
while (lo <= hi) {
int i = lo + ((hi - lo) >> 1);
int c = comparer.Compare(items[i], value);
if (c == 0) return i;
if (c < 0) {
lo = i + 1;
} else {
hi = i - 1;
}
}
return ~lo;
}
/// <summary>
/// Like <see cref="binary_search{T}(IList{T}, T, IComparer{T})"/>, but doesn't require deterministic sort
/// (i.e., a comparison of adjacent items in the collection may yield '0').
/// </summary>
public static int binary_search<T>(IList<T> items, T value, IComparer<T> comparer, IEqualityComparer<T> eq_comparer) =>
binary_search(items, value, 0, items.Count, comparer, eq_comparer);
/// <summary>
/// Like <see cref="binary_search{T}(IList{T}, T, int, int, IComparer{T})"/>, but doesn't require deterministic sort
/// (i.e., a comparison of adjacent items in the collection may yield '0').
/// </summary>
public static int binary_search<T>(IList<T> items, T value, int index, int length, IComparer<T> comparer, IEqualityComparer<T> eq_comparer) {
if (comparer == null) comparer = Comparer<T>.Default;
int lo = index;
int hi = index + length - 1;
while (lo <= hi) {
int i = lo + ((hi - lo) >> 1);
int c = comparer.Compare(items[i], value);
if (c == 0) {
if (eq_comparer.Equals(items[i], value)) {
return i;
} else {
lo = i;
goto try_find_exact;
}
}
if (c < 0) {
lo = i + 1;
} else {
hi = i - 1;
}
}
return ~lo;
try_find_exact:
// move right
for (hi = lo + 1; hi < items.Count && comparer.Compare(items[hi], value) == 0; hi++) {
if (eq_comparer.Equals(items[hi], value))
return hi;
}
hi = lo;
// move left
while (--lo >= 0 && comparer.Compare(items[lo], value) == 0) {
if (eq_comparer.Equals(items[lo], value))
return lo;
}
return ~hi;
}
public static void reflect_change<T, TData>(IList<T> target, IEnumerable<TData> source, Func<TData, T> create_item, Action<T> on_removed, NotifyCollectionChangedEventArgs e) {
switch (e.Action) {
case NotifyCollectionChangedAction.Add:
int i = e.NewStartingIndex;
foreach (TData d in e.NewItems) {
T item = create_item(d);
target.Insert(i++, item);
}
break;
case NotifyCollectionChangedAction.Move:
if (e.OldStartingIndex > e.NewStartingIndex) {
i = e.OldStartingIndex;
foreach (TData d in e.OldItems) {
var v = target[i];
target.RemoveAt(i++);
target.Insert(e.NewStartingIndex, v);
}
} else {
foreach (TData d in e.OldItems) {
var v = target[e.OldStartingIndex];
target.RemoveAt(e.OldStartingIndex);
target.Insert(e.NewStartingIndex, v);
}
}
break;
case NotifyCollectionChangedAction.Remove:
for (int x = 0; x < e.OldItems.Count; x++) {
T item = target[e.OldStartingIndex];
target.RemoveAt(e.OldStartingIndex);
on_removed?.Invoke(item);
}
break;
case NotifyCollectionChangedAction.Replace:
i = e.NewStartingIndex;
foreach (TData d in e.NewItems) {
T old_item = target[i];
target[i++] = create_item(d);
on_removed?.Invoke(old_item);
}
break;
case NotifyCollectionChangedAction.Reset:
var old_views = target.ToArray();
target.Clear();
if (on_removed != null) foreach (T item in old_views) on_removed(item);
foreach (TData d in source) target.Add(create_item(d));
break;
}
}
public static void reflect_change<T, TData>(IList<T> target, IEnumerable<TData> source, Func<TData, int, T> create_item, Action<T> on_removed, NotifyCollectionChangedEventArgs e) {
switch (e.Action) {
case NotifyCollectionChangedAction.Add: {
int i = e.NewStartingIndex;
foreach (TData d in e.NewItems) {
T item = create_item(d, i);
target.Insert(i++, item);
}
}
break;
case NotifyCollectionChangedAction.Move: {
if (e.OldStartingIndex > e.NewStartingIndex) {
int i = e.OldStartingIndex;
foreach (TData d in e.OldItems) {
var v = target[i];
target.RemoveAt(i++);
target.Insert(e.NewStartingIndex, v);
}
} else {
foreach (TData d in e.OldItems) {
var v = target[e.OldStartingIndex];
target.RemoveAt(e.OldStartingIndex);
target.Insert(e.NewStartingIndex, v);
}
}
}
break;
case NotifyCollectionChangedAction.Remove: {
for (int i = 0; i < e.OldItems.Count; i++) {
T item = target[e.OldStartingIndex];
target.RemoveAt(e.OldStartingIndex);
on_removed?.Invoke(item);
}
}
break;
case NotifyCollectionChangedAction.Replace: {
int i = e.NewStartingIndex;
foreach (TData d in e.NewItems) {
T old_item = target[i];
target[i] = create_item(d, i);
on_removed?.Invoke(old_item);
i++;
}
}
break;
case NotifyCollectionChangedAction.Reset: {
var old_views = target.ToArray();
target.Clear();
int i;
if (on_removed != null) {
for (i = 0; i < old_views.Length; i++)
on_removed(old_views[i]);
}
i = 0;
foreach (TData d in source)
target.Add(create_item(d, i++));
}
break;
}
}
public static void process_new_items<T>(IEnumerable<T> source, Action<T> on_new_item, NotifyCollectionChangedEventArgs e) {
switch (e.Action) {
case NotifyCollectionChangedAction.Add:
case NotifyCollectionChangedAction.Replace:
foreach (T v in e.NewItems)
on_new_item(v);
break;
case NotifyCollectionChangedAction.Reset:
foreach (T v in source)
on_new_item(v);
break;
}
}
// Note: this is not optimized, be wary of use with large collections
public static void sync_with_never_duplicate<T>(IList<T> dest, IEnumerable<T> src) =>
sync_with_never_duplicate(dest, src, EqualityComparer<T>.Default);
// Note: this is not optimized, be wary of use with large collections
public static void sync_with_never_duplicate<T>(IList<T> dest, IEnumerable<T> src, IEqualityComparer<T> comp) {
var src_list = src as IList<T> ?? new List<T>(src);
var src_set = src as ISet<T> ?? new HashSet<T>(src_list);
for (int i = 0; i < dest.Count; i++) {
if (!src_set.Contains(dest[i]))
dest.RemoveAt(i);
}
for (int i = 0; i < src_list.Count; i++) {
int curr_index = dest.IndexOf(src_list[i]);
if (curr_index == i) {
continue;
} else if (curr_index >= 0 && curr_index < dest.Count) {
dest.RemoveAt(curr_index);
}
dest.Insert(i, src_list[i]);
}
}
public static void sync_with_never_duplicate<T, TSource, TKey>(ObservableCollection<T> dest, IEnumerable<TSource> src, Func<TSource, T> create, Func<T, TKey> key, Func<TSource, TKey> src_key) =>
sync_with_never_duplicate(dest, src, create, key, src_key, EqualityComparer<TKey>.Default);
// Note: this is not optimized, be wary of use with large collections
public static void sync_with_never_duplicate<T, TSource, TKey>(ObservableCollection<T> dest, IEnumerable<TSource> src, Func<TSource, T> create, Func<T, TKey> key_selector, Func<TSource, TKey> src_key_selector, IEqualityComparer<TKey> key_comparer) {
var src_list = src as IList<TSource> ?? new List<TSource>(src);
var src_map = src_list.ToDictionary(src_key_selector);
for (int i = 0; i < dest.Count; i++) {
var k = key_selector(dest[i]);
if (!src_map.ContainsKey(k))
dest.RemoveAt(i);
}
var dest_map = dest.ToDictionary(key_selector);
for (int i = 0; i < src_list.Count; i++) {
TKey key = src_key_selector(src_list[i]);
if (dest_map.TryGetValue(key, out T dval)) {
int curr_index = dest.IndexOf(dval);
if (curr_index != i) {
dest.RemoveAt(curr_index);
dest.Insert(i, dval);
}
} else {
dest.Insert(i, create(src_list[i]));
}
}
}
public static TResult[] convert_array<T, TResult>(T[] source, Func<T, TResult> selector) {
TResult[] rv = new TResult[source.Length];
for (int i = 0; i < rv.Length; i++)
rv[i] = selector(source[i]);
return rv;
}
public static ICollection<TResult> wrap_selector<T, TResult>(ICollection<T> source, Func<T, TResult> convert, Func<TResult, T> convert_back) =>
new CollectionWrapper<T, TResult>(source, convert, convert_back);
public static void wrap_selector<T, TResult>(IReadOnlyCollection<T> source, Func<T, TResult> selector, out IReadOnlyCollection<TResult> as_ro_collection, out ICollection<TResult> as_collection) {
var wrapper = new ROCollectionWrapper<T, TResult>(source, selector);
as_ro_collection = wrapper;
as_collection = wrapper;
}
public static IReadOnlyCollection<T> wrap_mutable_as_read_only<T>(ICollection<T> source) =>
new MutableToReadOnlyCollectionWrapper<T>(source);
public static IReadOnlyCollection<TResult> wrap_mutable_as_read_only<T, TResult>(ICollection<T> source, Func<T, TResult> selector) =>
new MutableToReadOnlyCollectionWrapper<T, TResult>(source, selector);
class CollectionWrapper<TIn, TOut> : ICollection<TOut>, IReadOnlyCollection<TOut> {
readonly ICollection<TIn> _source;
readonly Func<TIn, TOut> _convert;
readonly Func<TOut, TIn> _convert_back;
public CollectionWrapper(ICollection<TIn> source, Func<TIn, TOut> convert, Func<TOut, TIn> convert_back) {
_source = source;
_convert = convert;
_convert_back = convert_back;
}
public int Count => _source.Count;
public bool IsReadOnly => _source.IsReadOnly || _convert_back == null;
public void Add(TOut item) => _source.Add(_convert_back(item));
public void Clear() => _source.Clear();
public bool Contains(TOut item) => _source.Contains(_convert_back(item));
public void CopyTo(TOut[] array, int arrayIndex) {
foreach (var v in _source)
array[arrayIndex++] = _convert(v);
}
public IEnumerator<TOut> GetEnumerator() {
foreach (var v in _source)
yield return _convert(v);
}
public bool Remove(TOut item) => _source.Remove(_convert_back(item));
IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}
class ROCollectionWrapper<TIn, TOut> : IReadOnlyCollection<TOut>, ICollection<TOut> {
readonly Func<TIn, TOut> _convert;
readonly IReadOnlyCollection<TIn> _source;
public ROCollectionWrapper(IReadOnlyCollection<TIn> source, Func<TIn, TOut> convert) {
_source = source;
_convert = convert;
}
public int Count => _source.Count;
public bool IsReadOnly => true;
void ICollection<TOut>.Add(TOut item) => throw new NotImplementedException();
bool ICollection<TOut>.Remove(TOut item) => throw new NotImplementedException();
void ICollection<TOut>.Clear() => throw new NotImplementedException();
public bool Contains(TOut item) {
foreach (var v in _source) {
if (Equals(v, _convert(v)))
return true;
}
return false;
}
public void CopyTo(TOut[] array, int arrayIndex) {
foreach (var v in _source)
array[arrayIndex++] = _convert(v);
}
public IEnumerator<TOut> GetEnumerator() {
foreach (var v in _source)
yield return _convert(v);
}
IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}
/// <summary>
/// An <see cref="IReadOnlyCollection{T}"/> wrapper for an underlying <see cref="ICollection{T}"/>.
/// </summary>
class MutableToReadOnlyCollectionWrapper<T> : IReadOnlyCollection<T> {
readonly ICollection<T> _source;
public MutableToReadOnlyCollectionWrapper(ICollection<T> source) =>
_source = source ?? throw new ArgumentNullException(nameof(source));
public int Count => _source.Count;
public IEnumerator<T> GetEnumerator() => _source.GetEnumerator();
IEnumerator IEnumerable.GetEnumerator() => _source.GetEnumerator();
}
/// <summary>
/// An <see cref="IReadOnlyCollection{TOut}"/> wrapper for an underlying <see cref="ICollection{TIn}"/>.
/// </summary>
class MutableToReadOnlyCollectionWrapper<TIn, TOut> : IReadOnlyCollection<TOut> {
readonly ICollection<TIn> _source;
readonly Func<TIn, TOut> _convert;
public MutableToReadOnlyCollectionWrapper(ICollection<TIn> source, Func<TIn, TOut> convert) {
_source = source ?? throw new ArgumentNullException(nameof(source));
_convert = convert ?? throw new ArgumentNullException(nameof(convert));
}
public int Count => _source.Count;
public IEnumerator<TOut> GetEnumerator() {
foreach (var v in _source)
yield return _convert(v);
}
IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}
}
}