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);
}
