public virtual IComparer <JProperty> Create(IJsonPropertyFormat format) { if (format == null) { throw new ArgumentNullException(nameof(format)); } var comparer = new CompositeComparer <JProperty>(); if (format.PinPaths.Any()) { var pinJsonPropertyComparer = new PinJsonPropertyComparer { Descending = format.PinDirection == ListSortDirection.Descending }; foreach (var path in format.PinPaths) { pinJsonPropertyComparer.PinPaths.Add(path); } comparer.Comparers.Add(pinJsonPropertyComparer); } if (format.AlphabeticalSort) { comparer.Comparers.Add(new AlphabeticalJsonPropertyComparer { Comparison = format.AlphabeticalComparison, Descending = format.AlphabeticalSortDirection == ListSortDirection.Descending }); } return(comparer); }
public void Task_03_Single_Priority() { var pc = new PriorityComparer <Item>("Z"); var dc = new DelegateComparer <Item>(CompareFirstName); var c = new CompositeComparer <Item>(new IComparer <Item>[] { pc, dc }); var z = new Item("Z"); c.Compare(A, z).Should().BeGreaterThan(0); c.Compare(z, A).Should().BeLessThan(0); }
public void TestCompositeComparer() { CompositeComparer comparer = new CompositeComparer( new ObjectPropertyComparer(typeof(Product), "Name"), new ObjectPropertyComparer(typeof(Product), "Price") ); Array.Sort(_products, comparer); AssertProducts(_product2, _product1, _product4, _product3); }
public void Task_05_Priority_Sort_Descending() { var pc = new PriorityComparer <Item>("Z", "Y"); var dc = new DelegateComparer <Item>(CompareFirstNameDescending); var c = new CompositeComparer <Item>(new IComparer <Item>[] { pc, dc }); var z = new Item("Z"); var y = new Item("Y"); var array = new[] { A, z, B, A1, y }; Array.Sort(array, c); array.SequenceEqual(new[] { z, y, B, A1, A }).Should().BeTrue(); }
public void Task_06_MultiLevel() { var pc = new DelegateComparer <Item>(CompareFirstName); var dc = new DelegateComparer <Item>(CompareLastName); var c = new CompositeComparer <Item>(new IComparer <Item>[] { pc, dc }); var a1 = new Item("a1", "Zhang", "A"); var b1 = new Item("b1", "Zhang", "B"); var c1 = new Item("c1", "Chen", "C"); var array = new[] { a1, b1, c1 }; Array.Sort(array, c); array.SequenceEqual(new[] { c1, a1, b1 }).Should().BeTrue(); }
/// <summary> /// /// </summary> /// <param name="timbres"></param> /// <param name="sortKeys"></param> public static void SortBy(List <Timbre> timbres, IEnumerable <ESortKey> sortKeys) { CompositeComparer <Timbre> comparers = new CompositeComparer <Timbre>(); foreach (ESortKey key in sortKeys) { comparers.Comparers.Add(new TimbreComparer(key)); } Debug.Assert(comparers.Comparers.Count == (int)ESortKey.Last); timbres.Sort(comparers); }
public static IComparer <T> Add <T>(IComparer <T> first, IComparer <T> second) { CompositeComparer <T> comparer = first as CompositeComparer <T>; if (comparer != null) { return(comparer.Add(second, false)); } CompositeComparer <T> comparer2 = first as CompositeComparer <T>; if (comparer2 != null) { return(comparer2.Add(first, true)); } return(new CompositeComparer <T>(new IComparer <T>[] { first, second })); }
public static IEnumerable <T> Sort <T>(this IEnumerable <T> contents, ICollectionSettings settings) where T : IContent { if (contents == null) { throw new ArgumentNullException(nameof(contents)); } // ReSharper disable InvertIf if (settings?.Comparers != null && settings.Comparers.Any()) { var comparer = new CompositeComparer <IContent>(settings.Comparers); contents = contents.OrderBy(content => content, comparer); } // ReSharper restore InvertIf return(contents); }
public IOrderedAsyncEnumerable <TElement> CreateOrderedEnumerable <TKey1>(Func <TElement, Task <TKey1> > keySelector, IComparer <TKey1>?comparer, bool descending) { if (keySelector == null) { throw new ArgumentNullException(nameof(keySelector)); } comparer ??= Comparer <TKey1> .Default; if (descending) { comparer = new ReverseComparer <TKey1>(comparer); } var currentKeySelector = _keySelector ?? (a => _valueKeySelector !(a).AsTask()); async Task <(TKey, TKey1)> newKeySelector(TElement a) => (await currentKeySelector(a), await keySelector(a)); var newKeyComparer = new CompositeComparer <TKey, TKey1>(_comparer, comparer); return(new OrderedAsyncEnumerable <TElement, (TKey, TKey1)>(_inner, newKeyComparer, newKeySelector, null)); }
protected internal virtual IComparer <T> CreateInternal(IXmlNodeFormat format) { if (format == null) { throw new ArgumentNullException(nameof(format)); } var comparer = new CompositeComparer <T>(); if (format.PinPaths.Any()) { var pinXmlNodeComparer = new PinXmlNodeComparer { Descending = format.PinDirection == ListSortDirection.Descending }; foreach (var path in format.PinPaths) { pinXmlNodeComparer.PinPaths.Add(path); } comparer.Comparers.Add(pinXmlNodeComparer); } if (format.AlphabeticalNameSort) { comparer.Comparers.Add(new AlphabeticalXmlNodeNameComparer { Comparison = format.AlphabeticalNameComparison, Descending = format.AlphabeticalNameSortDirection == ListSortDirection.Descending }); } if (format.AlphabeticalValueSort) { comparer.Comparers.Add(new AlphabeticalXmlNodeValueComparer { Comparison = format.AlphabeticalValueComparison, Descending = format.AlphabeticalValueSortDirection == ListSortDirection.Descending }); } return(comparer); }
public void Task_03_Single_Descending(Item x, Item y, bool?result) { var dc = new DelegateComparer <Item>(CompareFirstNameDescending); var c = new CompositeComparer <Item>(new[] { dc }); var v = c.Compare(x, y); if (v == 0) { result.Should().BeNull(); return; } if (v < 0) { result.Should().BeTrue(); return; } result.Should().BeFalse(); }
public void Compare_IfOneComparerReturnNotZero_TheNextComparerShouldNotBeCalled() { var returnValue = -1; var compositeComparer = new CompositeComparer <object>(this.CreateComparer <object>(returnValue), this.CreateComparer <object>(Times.Never())); Assert.AreEqual(returnValue, compositeComparer.Compare(new object(), new object())); returnValue = -10; compositeComparer = new CompositeComparer <object>(this.CreateComparer <object>(returnValue), this.CreateComparer <object>(Times.Never())); Assert.AreEqual(returnValue, compositeComparer.Compare(new object(), new object())); returnValue = 1; compositeComparer = new CompositeComparer <object>(this.CreateComparer <object>(returnValue), this.CreateComparer <object>(Times.Never())); Assert.AreEqual(returnValue, compositeComparer.Compare(new object(), new object())); returnValue = 70; compositeComparer = new CompositeComparer <object>(this.CreateComparer <object>(returnValue), this.CreateComparer <object>(Times.Never())); Assert.AreEqual(returnValue, compositeComparer.Compare(new object(), new object())); }
public void TestComparison() { var comparer = new CompositeComparer <string, string>( StringComparer.Create(CultureInfo.InvariantCulture, true), StringComparer.Create(CultureInfo.InvariantCulture, false) ); ComparerTestUtils.TestComparison( comparer, new List <(string, string)>() { (string.Empty, string.Empty), (string.Empty, "world"), (string.Empty, "world1"), ("hello", string.Empty), ("hello", "world"), ("hello", "world1"), ("hello1", string.Empty), ("hello1", "world"), ("hello1", "world1"), } ); }
public IEnumerable <IComparer <int> > Composes_correctly(IEnumerable <IComparer <int> > comparers) { CompositeComparer <int> comparer = (CompositeComparer <int>)comparers.Aggregate((c1, c2) => c1.ThenBy(c2)); return(comparer._comparers); }
private int InternalBinarySearch(int index, int count, T item, bool checkForEquality) { int lo = index; int hi = index + count - 1; while (lo <= hi) { int mid = lo + ((hi - lo) >> 1); // Ignore items that need to be resorted int usableMid = mid; while (usableMid <= hi && LiveShapingItems[BackingList[usableMid]].IsSortDirty) { if (checkForEquality && EqualityComparer.Equals(BackingList[usableMid], item)) { return(usableMid); } usableMid++; } if (usableMid > hi) { //everything in [mid,hi] had a dirty sort usableMid = mid - 1; while (usableMid >= lo && LiveShapingItems[BackingList[usableMid]].IsSortDirty) { if (checkForEquality && EqualityComparer.Equals(BackingList[usableMid], item)) { return(usableMid); } usableMid--; } if (usableMid < lo) { //everything in [lo,hi] was dirty, so place it after that interval return(~(hi + 1)); } var usableOrder = CompositeComparer.Compare(item, BackingList[usableMid]); if (usableOrder == 0) { return(checkForEquality && !EqualityComparer.Equals(BackingList[usableMid], item) ? ~usableMid : usableMid); } if (usableOrder < 0) { hi = usableMid - 1; } else { //we already checked that [mid,hi] is dirty, so instead of setting lo = mid + 1 we can just end here return(~(hi + 1)); } } else { var usableOrder = CompositeComparer.Compare(item, BackingList[usableMid]); if (usableOrder == 0) { return(checkForEquality && !EqualityComparer.Equals(BackingList[usableMid], item) ? ~usableMid : usableMid); } // we know that [mid,usableMid) are dirty and should be ignored if (usableOrder < 0) { hi = mid - 1; } else { lo = usableMid + 1; } } } return(~lo); }