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(IList items, T value, IComparer comparer) => binary_search(items, value, 0, items.Count, comparer); public static int binary_search(IList items, T value, int index, int length, IComparer comparer) { if (comparer == null) comparer = Comparer.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; } /// /// Like , but doesn't require deterministic sort /// (i.e., a comparison of adjacent items in the collection may yield '0'). /// public static int binary_search(IList items, T value, IComparer comparer, IEqualityComparer eq_comparer) => binary_search(items, value, 0, items.Count, comparer, eq_comparer); /// /// Like , but doesn't require deterministic sort /// (i.e., a comparison of adjacent items in the collection may yield '0'). /// public static int binary_search(IList items, T value, int index, int length, IComparer comparer, IEqualityComparer eq_comparer) { if (comparer == null) comparer = Comparer.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(IList target, IEnumerable source, Func create_item, Action 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(IList target, IEnumerable source, Func create_item, Action 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(IEnumerable source, Action 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(IList dest, IEnumerable src) => sync_with_never_duplicate(dest, src, EqualityComparer.Default); // Note: this is not optimized, be wary of use with large collections public static void sync_with_never_duplicate(IList dest, IEnumerable src, IEqualityComparer comp) { var src_list = src as IList ?? new List(src); var src_set = src as ISet ?? new HashSet(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(ObservableCollection dest, IEnumerable src, Func create, Func key, Func src_key) => sync_with_never_duplicate(dest, src, create, key, src_key, EqualityComparer.Default); // Note: this is not optimized, be wary of use with large collections public static void sync_with_never_duplicate(ObservableCollection dest, IEnumerable src, Func create, Func key_selector, Func src_key_selector, IEqualityComparer key_comparer) { var src_list = src as IList ?? new List(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[] source, Func 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 wrap_selector(ICollection source, Func convert, Func convert_back) => new CollectionWrapper(source, convert, convert_back); public static void wrap_selector(IReadOnlyCollection source, Func selector, out IReadOnlyCollection as_ro_collection, out ICollection as_collection) { var wrapper = new ROCollectionWrapper(source, selector); as_ro_collection = wrapper; as_collection = wrapper; } public static IReadOnlyCollection wrap_mutable_as_read_only(ICollection source) => new MutableToReadOnlyCollectionWrapper(source); public static IReadOnlyCollection wrap_mutable_as_read_only(ICollection source, Func selector) => new MutableToReadOnlyCollectionWrapper(source, selector); class CollectionWrapper : ICollection, IReadOnlyCollection { readonly ICollection _source; readonly Func _convert; readonly Func _convert_back; public CollectionWrapper(ICollection source, Func convert, Func 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 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 : IReadOnlyCollection, ICollection { readonly Func _convert; readonly IReadOnlyCollection _source; public ROCollectionWrapper(IReadOnlyCollection source, Func convert) { _source = source; _convert = convert; } public int Count => _source.Count; public bool IsReadOnly => true; void ICollection.Add(TOut item) => throw new NotImplementedException(); bool ICollection.Remove(TOut item) => throw new NotImplementedException(); void ICollection.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 GetEnumerator() { foreach (var v in _source) yield return _convert(v); } IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); } /// /// An wrapper for an underlying . /// class MutableToReadOnlyCollectionWrapper : IReadOnlyCollection { readonly ICollection _source; public MutableToReadOnlyCollectionWrapper(ICollection source) => _source = source ?? throw new ArgumentNullException(nameof(source)); public int Count => _source.Count; public IEnumerator GetEnumerator() => _source.GetEnumerator(); IEnumerator IEnumerable.GetEnumerator() => _source.GetEnumerator(); } /// /// An wrapper for an underlying . /// class MutableToReadOnlyCollectionWrapper : IReadOnlyCollection { readonly ICollection _source; readonly Func _convert; public MutableToReadOnlyCollectionWrapper(ICollection source, Func convert) { _source = source ?? throw new ArgumentNullException(nameof(source)); _convert = convert ?? throw new ArgumentNullException(nameof(convert)); } public int Count => _source.Count; public IEnumerator GetEnumerator() { foreach (var v in _source) yield return _convert(v); } IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); } } }