129 lines
4.0 KiB
C#
129 lines
4.0 KiB
C#
#nullable enable
|
|
namespace mbts.utils {
|
|
using bts.utils;
|
|
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
|
|
public static class ComparerBuilder {
|
|
public static IComparer<T> create_comparer<T>(params IComparer<T>[] comparers) =>
|
|
create(comparers).to_comparer();
|
|
|
|
public static IComparer<T> create_comparer<T>(IEnumerable<IComparer<T>> comparers) =>
|
|
create(comparers).to_comparer();
|
|
|
|
public static ComparerBuilder<T> create<T>(params IComparer<T>[] comparers) =>
|
|
new(comparers);
|
|
|
|
public static ComparerBuilder<T> create<T>(IEnumerable<IComparer<T>> comparers) =>
|
|
new(comparers);
|
|
}
|
|
|
|
public class ComparerBuilder<T> : IList<IComparer<T>>, IComparer<T> {
|
|
readonly List<IComparer<T>> _comparers;
|
|
|
|
public ComparerBuilder() =>
|
|
_comparers = new(2);
|
|
|
|
public ComparerBuilder(params IComparer<T>[] comparers) {
|
|
_comparers = new(comparers.Length);
|
|
for (int i = 0; i < comparers.Length; i++) {
|
|
_comparers.Add(comparers[i]);
|
|
}
|
|
}
|
|
|
|
public ComparerBuilder(IEnumerable<IComparer<T>> comparers) =>
|
|
_comparers = new(comparers);
|
|
|
|
public int Count => _comparers.Count;
|
|
public bool IsReadOnly => false;
|
|
|
|
public IComparer<T> this[int index] {
|
|
get => _comparers[index];
|
|
set => _comparers[index] = value;
|
|
}
|
|
|
|
public void Add(IComparer<T> item) =>
|
|
_comparers.Add(item);
|
|
|
|
public void Add<TValue>(Func<T, TValue> get) =>
|
|
Add(get, Comparer<TValue>.Default);
|
|
|
|
public void Add<TValue>(Func<T, TValue> get, IComparer<TValue> comparer) =>
|
|
Add(CompareUtils.wrap(comparer, get));
|
|
|
|
public void Clear() =>
|
|
_comparers.Clear();
|
|
|
|
public bool Contains(IComparer<T> item) =>
|
|
_comparers.Contains(item);
|
|
|
|
public void CopyTo(IComparer<T>[] array, int array_index) =>
|
|
_comparers.CopyTo(array, array_index);
|
|
|
|
public IEnumerator<IComparer<T>> GetEnumerator() =>
|
|
_comparers.GetEnumerator();
|
|
|
|
public int IndexOf(IComparer<T> item) =>
|
|
_comparers.IndexOf(item);
|
|
|
|
public void Insert(int index, IComparer<T> item) =>
|
|
_comparers.Insert(index, item);
|
|
|
|
public bool Remove(IComparer<T> item) =>
|
|
_comparers.Remove(item);
|
|
|
|
public void RemoveAt(int index) =>
|
|
_comparers.RemoveAt(index);
|
|
|
|
public IComparer<T> to_comparer() =>
|
|
new _Comparer(_comparers.ToArray());
|
|
|
|
public ComparerBuilder<T> append<TInner>(Func<T, TInner> selector) =>
|
|
append(selector, Comparer<TInner>.Default);
|
|
|
|
public ComparerBuilder<T> append<TInner>(
|
|
Func<T, TInner> selector, IComparer<TInner> inner_comparer) {
|
|
Add(selector, inner_comparer);
|
|
return this;
|
|
}
|
|
|
|
public IComparer<T> to_comparer<TInner>(Func<T, TInner> selector) =>
|
|
to_comparer(selector, Comparer<TInner>.Default);
|
|
|
|
public IComparer<T> to_comparer<TInner>(
|
|
Func<T, TInner> selector, IComparer<TInner> inner_comparer) {
|
|
Add(selector, inner_comparer);
|
|
return to_comparer();
|
|
}
|
|
|
|
public int Compare(T? x, T? y) =>
|
|
_compare(_comparers, x, y);
|
|
|
|
static int _compare<TComparers>(TComparers comparers, T? x, T? y)
|
|
where TComparers : IEnumerable<IComparer<T>> {
|
|
foreach (var comp in comparers) {
|
|
int result = comp.Compare(x, y);
|
|
if (result != 0) {
|
|
return result;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
IEnumerator IEnumerable.GetEnumerator() =>
|
|
_comparers.GetEnumerator();
|
|
|
|
class _Comparer : IComparer<T> {
|
|
readonly IComparer<T>[] _comparers;
|
|
|
|
public _Comparer(IComparer<T>[] comparers) =>
|
|
_comparers = comparers;
|
|
|
|
public int Compare(T? x, T? y) =>
|
|
_compare(_comparers, x, y);
|
|
}
|
|
}
|
|
}
|