561 lines
23 KiB
C#
561 lines
23 KiB
C#
namespace bts.utils {
|
|
using bts.collections;
|
|
|
|
using Spark.Core.Collections;
|
|
using Spark.Core.Disposables;
|
|
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Collections.Specialized;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
|
|
public static class CollectionHelper {
|
|
public const string indexer_name = "Item[]";
|
|
|
|
public static int binary_search<T>(IList<T> items, T value) =>
|
|
binary_search(items, value, 0, items.Count, Comparer<T>.Default);
|
|
|
|
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;
|
|
}
|
|
|
|
public static int binary_search<T, TKey>(IList<T> items, TKey value, Func<T, TKey> key_selector) =>
|
|
binary_search(items, value, 0, items.Count, Comparer<TKey>.Default, key_selector);
|
|
|
|
public static int binary_search<T, TKey>(IList<T> items, TKey value, IComparer<TKey> comparer, Func<T, TKey> key_selector) =>
|
|
binary_search(items, value, 0, items.Count, comparer, key_selector);
|
|
|
|
public static int binary_search<T, TKey>(IList<T> items, TKey key, int index, int length, IComparer<TKey> comparer, Func<T, TKey> key_selector) =>
|
|
binary_search(new SelectorList<T, TKey>(items, key_selector, null), key, index, length, comparer);
|
|
|
|
/// <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 IDisposable buffer_collection_changed_callback(INotifyCollectionChanged source, Action callback, TimeSpan delay_before_callback, TimeSpan delay_after_callback) {
|
|
// return CallbackBuffer.buffer_callback(attach_callback, callback, delay_before_callback, delay_after_callback);
|
|
// IDisposable attach_callback(Action cb) {
|
|
// source.CollectionChanged += on_collection_changed;
|
|
// return Disposable.Create(() => source.CollectionChanged -= on_collection_changed);
|
|
// void on_collection_changed(object sender, NotifyCollectionChangedEventArgs e) =>
|
|
// cb();
|
|
// }
|
|
return CallbackBuffer.buffer_async_callback(attach_callback, impl);
|
|
IDisposable attach_callback(Action cb) {
|
|
source.CollectionChanged += on_collection_changed;
|
|
return Disposable.Create(() => source.CollectionChanged -= on_collection_changed);
|
|
void on_collection_changed(object? sender, NotifyCollectionChangedEventArgs e) =>
|
|
cb();
|
|
}
|
|
async Task impl() {
|
|
if (delay_before_callback > TimeSpan.Zero)
|
|
await Task.Delay(delay_before_callback);
|
|
callback();
|
|
if (delay_after_callback > TimeSpan.Zero)
|
|
await Task.Delay(delay_after_callback);
|
|
}
|
|
}
|
|
|
|
public static ICollection<T> empty<T>() =>
|
|
Array.Empty<T>();
|
|
|
|
public static string fmt_collection_change(NotifyCollectionChangedEventArgs e) {
|
|
return e.Action switch {
|
|
NotifyCollectionChangedAction.Add => $"Insert at {e.NewStartingIndex} [{fmt_items(e.NewItems!)}]",
|
|
NotifyCollectionChangedAction.Remove => $"Remove from {e.OldStartingIndex} [{fmt_items(e.OldItems!)}]",
|
|
NotifyCollectionChangedAction.Move => $"Move from {e.OldStartingIndex} to {e.NewStartingIndex} [{fmt_items(e.NewItems!)}]",
|
|
NotifyCollectionChangedAction.Replace => $"Replace at {e.OldStartingIndex} [{fmt_items(e.OldItems!)}] with [{fmt_items(e.NewItems!)}]",
|
|
NotifyCollectionChangedAction.Reset => "Reset",
|
|
_ => $"Unknown-action {e.Action}"
|
|
};
|
|
|
|
static string fmt_items(IList items) =>
|
|
string.Join(", ", items.Cast<object>());
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
public static void sync_with_never_duplicate<T, TSource, TKey>(
|
|
IList<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>(
|
|
IList<T> dest,
|
|
IEnumerable<TSource> src,
|
|
Func<TSource, T> create,
|
|
Func<T, TKey> key_selector,
|
|
Func<TSource, TKey> src_key_selector,
|
|
IEqualityComparer<TKey> key_comparer) {
|
|
key_comparer ??= EqualityComparer<TKey>.Default;
|
|
var src_list = src as IList<TSource> ?? new List<TSource>(src);
|
|
#nullable disable
|
|
var src_map = src_list.ToDictionary(src_key_selector, key_comparer);
|
|
#nullable enable
|
|
for (int i = 0; i < dest.Count; i++) {
|
|
var k = key_selector(dest[i]);
|
|
if (!src_map.ContainsKey(k))
|
|
dest.RemoveAt(i);
|
|
}
|
|
|
|
#nullable disable
|
|
var dest_map = dest.ToDictionary(key_selector, key_comparer);
|
|
#nullable enable
|
|
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>? convertBackBacking;
|
|
|
|
public CollectionWrapper(ICollection<TIn> source, Func<TIn, TOut> convert, Func<TOut, TIn>? convert_back) {
|
|
_source = source;
|
|
_convert = convert;
|
|
convertBackBacking = convert_back;
|
|
}
|
|
|
|
public int Count => _source.Count;
|
|
public bool IsReadOnly => _source.IsReadOnly || _convert_back == null;
|
|
|
|
Func<TOut, TIn> _convert_back =>
|
|
convertBackBacking ?? throw new InvalidOperationException("ConvertBack delegate is 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();
|
|
}
|
|
|
|
public static void compare_hashsets<T>(HashSet<T> new_d, HashSet<T> old_d,
|
|
out HashSet<T> deleted_d, out HashSet<T> added_d) {
|
|
added_d = new HashSet<T>();
|
|
deleted_d = new HashSet<T>();
|
|
foreach (T t in new_d)
|
|
if (!old_d.Contains(t))
|
|
added_d.Add(t);
|
|
foreach (T t in old_d)
|
|
if (!new_d.Contains(t))
|
|
deleted_d.Add(t);
|
|
}
|
|
|
|
public static IEnumerable<T> append_arrays<T>(params IEnumerable<T>[] ienum_list) {
|
|
List<T> rv = new List<T>();
|
|
foreach (IEnumerable<T> ienum in ienum_list)
|
|
rv.AddRange(ienum);
|
|
return rv;
|
|
}
|
|
|
|
public static bool hashset_equals<T>(HashSet<T> new_d, HashSet<T> old_d) {
|
|
HashSet<T> deleted_d, added_d;
|
|
compare_hashsets(new_d, old_d, out deleted_d, out added_d);
|
|
return deleted_d.Count == 0 && added_d.Count == 0;
|
|
}
|
|
|
|
/// If key_selector returns the same key this
|
|
/// functions crushes it (in the Dict)
|
|
public static IDictionary<K, V> ToDictionaryDupes<K, V, T>(this IEnumerable<T> items, Func<T, K> key_selector, Func<T, V> value_selector) {
|
|
IDictionary<K, V> rv = new Dictionary<K, V>();
|
|
//(items ?? new List<T>()).ForEach(t => rv[key_selector(t)] = value_selector(t));
|
|
if (items != null) {
|
|
foreach (var t in items) {
|
|
rv[key_selector(t)] = value_selector(t);
|
|
}
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets coordinates for an index in the imaginary sorted list that results from merging
|
|
/// <paramref name="list1"/> and <paramref name="list2"/>. The "X" coordinate is either 0
|
|
/// (list1) or 1 (list2), and the "Y" coordinate is the index in that list.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of elements in the list</typeparam>
|
|
/// <param name="list1">One of two lists making up the imaginary sorted merged list</param>
|
|
/// <param name="index">The index in the imaginary sorted merged list for which to get coordinates</param>
|
|
/// <param name="list2">One of two lists making up the imaginary sorted merged list</param>
|
|
/// <param name="comparer">The comparer by which the elements are sorted</param>
|
|
/// <returns></returns>
|
|
/// <exception cref="IndexOutOfRangeException"></exception>
|
|
/// <exception cref="InvalidOperationException"></exception>
|
|
public static (int X, int Y) BinarySearchMergedIndex<T>(IList<T> list1, int index, IList<T> list2, IComparer<T> comparer) {
|
|
if (index < 0 || index >= list1.Count + list2.Count) {
|
|
throw new IndexOutOfRangeException();
|
|
}
|
|
if (list1.Count == 0) {
|
|
return (1, index);
|
|
}
|
|
if (list2.Count == 0) {
|
|
return (0, index);
|
|
}
|
|
int list1Start = binarySearchPosition(list2, list1[0], comparer);
|
|
if (index < list1Start) {
|
|
return (1, index);
|
|
}
|
|
if (index == list1Start) {
|
|
return (0, 0);
|
|
}
|
|
if (list1.Count == 1) {
|
|
return (1, index - 1);
|
|
}
|
|
list2 = list2.WrapSubRange(list1Start, list2.Count - list1Start);
|
|
index -= list1Start;
|
|
var res = binarySearchMergedIndex(list1, index, list2, comparer);
|
|
if (res.X == 1) {
|
|
res = (res.X, res.Y + list1Start);
|
|
}
|
|
return res;
|
|
|
|
static (int X, int Y) binarySearchMergedIndex(IList<T> list1, int index, IList<T> list2, IComparer<T> comparer) {
|
|
if (index < 0 || index >= list1.Count + list2.Count) {
|
|
throw new IndexOutOfRangeException();
|
|
}
|
|
int list1Count = list1.Count;
|
|
if (list1Count == 0) {
|
|
return (1, index);
|
|
}
|
|
int list2Count = list2.Count;
|
|
if (list2Count == 0) {
|
|
return (0, index);
|
|
}
|
|
if (list1Count > index + 1) {
|
|
list1 = list1.WrapSubRange(0, index + 1);
|
|
}
|
|
if (list2Count > index + 1) {
|
|
list2 = list2.WrapSubRange(0, index + 1);
|
|
}
|
|
int mid1 = list1.Count / 2;
|
|
int mid1Pos2 = binarySearchPosition(list2, list1[mid1], comparer);
|
|
int shift1 = 0;
|
|
int shift2 = 0;
|
|
if ((mid1 + mid1Pos2) > index) {
|
|
list1 = list1.WrapSubRange(0, mid1);
|
|
list2 = list2.WrapSubRange(0, mid1Pos2);
|
|
} else if ((mid1 + mid1Pos2) < index) {
|
|
index -= mid1 + mid1Pos2 + 1;
|
|
if (index < 0) {
|
|
throw new InvalidOperationException("Bad state (index became negative)");
|
|
}
|
|
shift1 += mid1 + 1;
|
|
list1 = list1.WrapSubRange(mid1 + 1);
|
|
shift2 += mid1Pos2;
|
|
list2 = list2.WrapSubRange(mid1Pos2);
|
|
} else {
|
|
return (0, mid1);
|
|
}
|
|
var (x, y) = binarySearchMergedIndex(list1, index, list2, comparer);
|
|
return x == 0
|
|
? (0, y + shift1)
|
|
: (1, y + shift2);
|
|
}
|
|
}
|
|
|
|
static int binarySearchPosition<T>(IList<T> list, T value, IComparer<T> comparer) {
|
|
int rv = list.BinarySearch(value, comparer);
|
|
if (rv < 0) {
|
|
rv = ~rv;
|
|
}
|
|
return rv;
|
|
}
|
|
}
|
|
}
|