/// <summary>
/// Validates that the specified value is between a specified exclusive minimum and maximum
/// value.
/// </summary>
/// <typeparam name="T">The type of the value being validated.</typeparam>
/// <param name="value">The value to validate is between the specified minimum and maximum
/// value.</param>
/// <param name="minValue">The minimum value to validate against.</param>
/// <param name="maxValue">The maximum value to validate against.</param>
/// <param name="valueName">The name of the parameter being validated.</param>
/// <param name="comparer">The comparer to use to compare the specified values.</param>
/// <exception cref="ArgumentOutOfRangeException"><paramref name="value"/> is less than or
/// equal to <paramref name="minValue"/>, or <paramref name="value"/> is greater than or
/// equal to <paramref name="maxValue"/>.</exception>
public static void IsBetween <T>(
T value,
T minValue,
T maxValue,
string valueName,
IComparer <T> comparer)
{
if (comparer?.Compare(value, minValue) <= 0 || comparer?.Compare(value, maxValue) >= 0)
{
throw new ArgumentOutOfRangeException(
valueName,
Invariant($"Value must be between {minValue} and {maxValue}."));
}
}
protected virtual int FindIndex(object item, object seed, IComparer comparer, int low, int high)
{
if (comparer != null)
{
ListComparer comparer2 = comparer as ListComparer;
if (comparer2 != null)
{
comparer2.Reset();
}
CollectionViewGroupComparer comparer3 = comparer as CollectionViewGroupComparer;
if (comparer3 != null)
{
comparer3.Reset();
}
int num = low;
while (num < high)
{
CollectionViewGroupInternal internal2 = base.ProtectedItems[num] as CollectionViewGroupInternal;
object y = (internal2 != null) ? internal2.SeedItem : base.ProtectedItems[num];
if ((y != DependencyProperty.UnsetValue) && (comparer.Compare(seed, y) < 0))
{
return num;
}
num++;
}
return num;
}
return high;
}
public int Compare(BenchmarkCase x, BenchmarkCase y)
{
if (x == null && y == null)
{
return(0);
}
if (x != null && y == null)
{
return(1);
}
if (x == null)
{
return(-1);
}
foreach (var rule in order)
{
int compare = rule switch
{
BenchmarkLogicalGroupRule.ByMethod => targetComparer?.Compare(x.Descriptor, y.Descriptor) ?? 0,
BenchmarkLogicalGroupRule.ByJob => jobComparer?.Compare(x.Job, y.Job) ?? 0,
BenchmarkLogicalGroupRule.ByParams => paramsComparer?.Compare(x.Parameters, y.Parameters) ?? 0,
BenchmarkLogicalGroupRule.ByCategory => categoryComparer?.Compare(x.Descriptor.Categories, y.Descriptor.Categories) ?? 0,
_ => throw new ArgumentOutOfRangeException()
};
if (compare != 0)
{
return(compare);
}
}
return(string.CompareOrdinal(x.DisplayInfo, y.DisplayInfo));
}
}
/// <summary>
/// Computes difference of two sorted sequences.
/// </summary>
/// <remarks>
/// <para>Both set1 and set2 must be sorted in ascending order with respect to comparer.</para>
/// <para>Difference contains elements present in set1, but not in set2.</para>
/// <para>Result is written to the output iterator one member at a time</para>
///
/// <para>For multisets, if set1 contains k equal elements, and set2 contains
/// m elements equal to those k, then max(k-m,0) elements from set1 are
/// included in the output.</para>
/// <para>Complexity: linear on combined number of items in both sequences</para>
/// </remarks>
/// <example>
/// <para>set1 = {"a", "b", "test", "tEst", "z" }</para>
/// <para>set2 = {"a", "TEST", "z", "Z" }</para>
/// <para>comparer = case insensitive comparer</para>
/// <para>output = {"b", "tEst"}</para>
/// </example>
public static void Difference(IEnumerable set1, IEnumerable set2, IComparer comparer, IOutputIterator output)
{
var enum1 = set1.GetEnumerator();
var enum2 = set2.GetEnumerator();
var have1 = enum1.MoveNext();
var have2 = enum2.MoveNext();
while (have1 && have2)
{
var compare = comparer.Compare(enum1.Current, enum2.Current);
if (compare < 0)
{
output.Add(enum1.Current);
have1 = enum1.MoveNext();
}
else if (compare > 0)
{
have2 = enum2.MoveNext();
}
else
{
have1 = enum1.MoveNext();
have2 = enum2.MoveNext();
}
}
while (have1)
{
output.Add(enum1.Current);
have1 = enum1.MoveNext();
}
}
/// <summary>
/// Don't overwrite already cached items
/// </summary>
/// <param name="txTimestamp"></param>
/// <param name="newVersion"></param>
/// <param name="comparator"></param>
/// <returns></returns>
public bool IsPuttable(long txTimestamp, object newVersion, IComparer comparator)
{
// we really could refresh the item if it
// is not a lock, but it might be slower
//return freshTimestamp < txTimestamp
return version != null && comparator.Compare(version, newVersion) < 0;
}
private static int Compare(IComparer<Object> comparer, Object[] array, int leftIndex, int rightIndex) {
// item 64
Object left = array[leftIndex];
Object right = array[rightIndex];
// item 56
return comparer.Compare(left, right);
}
private SetOp() { } // disable construction
/// <summary>
/// Computes union of two sorted sequences.
/// </summary>
/// <remarks>
/// <para>Both set1 and set2 must be sorted in ascending order with respect to comparer.</para>
/// <para>Union contains elements present in one or both ranges.</para>
/// <para>Result is written to the output iterator one member at a time</para>
///
/// <para>Union differs from <see cref="Merge">Merge</see> for multisets.</para>
///
/// <para>If k equal elements are present in set1 and m elements equal to those k
/// are present in set2,then k elements from set1 are included in the output,
/// followed by max(m-k, 0) elements from set2. The total of max(k,m) are
/// added to the output. If you'd like to have m+k elements, use Merge function.
/// </para>
/// <para>Complexity: linear on combined number of items in both sequences</para>
/// </remarks>
/// <example>
/// <para>set1 = { "a", "test", "Test", "z" }</para>
/// <para>set2 = { "b", "tEst", "teSt", "TEST", "Z" }</para>
/// <para>comparer is a case-insensitive comparer</para>
/// <para>The following elements will be added to output:
/// {"a", "b", "test", "Test", "TEST", "z" }</para>
/// </example>
public static void Union(IEnumerable set1, IEnumerable set2, IComparer comparer, IOutputIterator output) {
IEnumerator enum1 = set1.GetEnumerator();
IEnumerator enum2 = set2.GetEnumerator();
bool have1 = enum1.MoveNext();
bool have2 = enum2.MoveNext();
while (have1 && have2) {
int compare = comparer.Compare(enum1.Current, enum2.Current);
if (compare < 0) {
output.Add(enum1.Current);
have1 = enum1.MoveNext();
} else if (compare > 0) {
output.Add(enum2.Current);
have2 = enum2.MoveNext();
} else {
output.Add(enum1.Current);
have1 = enum1.MoveNext();
have2 = enum2.MoveNext();
}
}
while (have1) {
output.Add(enum1.Current);
have1 = enum1.MoveNext();
}
while (have2) {
output.Add(enum2.Current);
have2 = enum2.MoveNext();
}
}
public int Compare(Benchmark x, Benchmark y) => new[]
{
paramsComparer?.Compare(x.Parameters, y.Parameters) ?? 0,
jobComparer?.Compare(x.Job, y.Job) ?? 0,
targetComparer?.Compare(x.Target, y.Target) ?? 0,
string.CompareOrdinal(x.DisplayInfo, y.DisplayInfo)
}.FirstOrDefault(c => c != 0);
private int Compare(object x, object y)
{
int result = 0;
if (_propertyType == null)
{
if (x != null)
{
_propertyType = GetPropertyType(x);
}
if (_propertyType == null && y != null)
{
_propertyType = GetPropertyType(y);
}
}
object v1 = GetValue(x);
object v2 = GetValue(y);
if (_propertyType != null && _internalComparer == null)
{
_internalComparer = GetComparerForType(_propertyType);
}
result = _internalComparer?.Compare(v1, v2) ?? 0;
if (_descending)
{
return(-result);
}
else
{
return(result);
}
}
public static int Partition( this int[] arr, int start, int end, int pivot,
IComparer<int> comparer)
{
if ( pivot < start || pivot > end )
throw new IndexOutOfRangeException( "Pivot was out of range" );
if ( end <= start )
return pivot;
int pVal = arr[pivot];
arr.Swap( end, pivot );
int i = start, j = end - 1;
while ( i < j )
{
while ( i < j && comparer.Compare( arr[i], pVal ) <= 0 )
++i;
while ( i < j && comparer.Compare( arr[j], pVal ) > 0 )
--j;
if ( i < j )
arr.Swap( i, j );
}
if ( comparer.Compare( arr[i], pVal ) <= 0 )
++i;
arr[end] = arr[i];
arr[i] = pVal;
return i;
}
/// <summary>
/// A simple bubble sort for two arrays, limited to some region of the arrays.
/// This is a regular bubble sort, nothing fancy.
/// </summary>
public static void SimpleSort(Array array, Array items, int startingIndex, int length, IComparer comparer)
{
bool finished = false;
while (!finished)
{
bool swapped = false;
for (int g = startingIndex; g < startingIndex + length - 1; g++)
{
Object first = array.GetValue(g);
Object second = array.GetValue(g + 1);
int comparison = comparer.Compare(first, second);
if (comparison == 1)
{
Swap(g, g + 1, array, items);
swapped = true;
first = array.GetValue(g);
second = array.GetValue(g + 1);
}
}
if (!swapped)
{
finished = true;
}
}
}
private static void BubbleSort(int[][] array, IComparer comparer)
{
int length = array.Length;
for (int i = 0; i < length; i++)
for (int j = 0; j < length - i - 1; j++)
if (comparer.Compare(array[j], array[j+1]) > 0)
Swap(ref array[j], ref array[j + 1]);
}
public static void SortWithInterfaces(double[][] array, IComparer<double[]> comparer)
{
for (int i = 0; i < array.Length - 1; ++i)
for (int j = 0; j < array.Length - i - 1; ++j)
{
if (comparer.Compare(array[j], array[j + 1]) > 0)
Swap(ref array[j], ref array[j + 1]);
}
}
static bool Contains(IList list, object value, IComparer comparer)
{
foreach(object item in list) {
if(0 == comparer.Compare(item, value)) {
return true;
}
}
return false;
}
private void SortColumn(int idx, IComparer<Object> cmp)
{
for(int i = 1; i < table.Count; i++) {
for(int j = i; j > 0; j--)
{
if (cmp.Compare(table[j][idx], table[j - 1][idx]) > 0)
SwapTable(j, j - 1);
}
}
}
private static void BubbleSort(int[][] array, IComparer<int[]> comparer)
{
int n = array.Length;
while (n- 1 > 0)
{
for (int i = 0; i < array.Count() - 1; i++)
if (comparer.Compare(array[i], array[i + 1]) > 0)
Swap(ref array[i], ref array[i+1]);
n--;
}
}
///<param name="list">List to sort</param>
///<param name="lbound">Lower bound, smallest index to include in sort</param>
///<param name="ubound">Upper bound, larges index to include in sort</param>
///<param name="comparer">Object to compare collections elements and determine sort order</param>
public static void InsertionSort(IList list, int lbound, int ubound, IComparer comparer)
{
for(int i=lbound + 1; i <= ubound; i++) {
object item = list[i];
if(comparer.Compare(item, list[i-1]) < 0) {
//i is not in sorted order
list.RemoveAt(i);
SortedInsert(item, list, lbound, i-1, comparer);
}
}
}
public static void Sort(int[][] array, IComparer<int[]> compareArg)
{
for (int i = 0; i < array.GetLength(0) - 1; i++)
{
for (int j = i + 1; j < array.GetLength(0); j++)
{
if (compareArg.Compare(array[i], array[j]) > 0)
Swap(ref array[i], ref array[j]);
}
}
}
/// <summary>
/// Utility method to perform appropriate comparisons with the given comparer. A10 should
/// be less than B15 for all our tests
/// </summary>
static void TestComparisons(IComparer<NameAndNumber> comparer)
{
Assert.AreEqual(0, comparer.Compare(A10, A10));
Assert.AreEqual(0, comparer.Compare(B15, B15));
Assert.AreEqual(0, comparer.Compare(null, null));
Assert.Less(comparer.Compare(null, A10), 0);
Assert.Greater(comparer.Compare(A10, null), 0);
Assert.Less(comparer.Compare(A10, B15), 0);
Assert.Greater(comparer.Compare(B15, A10), 0);
}
public static void AreEqual(IComparer actual, IComparer expected, string message = null)
{
if (actual.Compare(actual, expected) != 0)
{
throw new Exception(@"Objects are different. Comment: {0}
Actual: {1}
Expect: {2}
Log file: {3}".FormatWith(message, actual, expected, LogFilePath));
}
}
/// <inheritdoc />
#pragma warning disable CS8767 // Nullability of reference types in type of parameter doesn't match implicitly implemented member (possibly because of nullability attributes).
public int Compare(T x, T y)
#pragma warning restore CS8767 // Nullability of reference types in type of parameter doesn't match implicitly implemented member (possibly because of nullability attributes).
{
int parentResult = _parent?.Compare(x, y) ?? 0;
if (x == null && y == null)
{
return(0);
}
return(parentResult != 0 ? parentResult : _inner(x, y));
}
public static void BubbleSort(string[] array, IComparer<string> comparer)
{
for (int i = 1; i < array.Length; i++)
{
for (int j = 0; j < array.Length - 1; j++)
{
if (comparer.Compare(array[j], array[j+1]) > 0)
{
Swap(ref array[j],ref array[j+1]);
}
}
}
}
public static int FindIndexStatistic( this int[] buffer, int index,
int start, int count, IComparer<int> comparer)
{
if ( index < start || index >= start + count )
throw new IndexOutOfRangeException();
int statistic = 0;
for ( int i = start; i < start + count; ++i )
if ( comparer.Compare( buffer[i], buffer[index] ) < 0 )
++statistic;
return statistic;
}
private static void Sort(int[][] array, IComparer<int[]> comparer)
{
for (int i = array.Length - 1; i >= 0; i--)
{
for (int j = 0; j < i; j++)
{
if (comparer.Compare(array[j], array[j + 1]) == 1)
{
SwapArray(ref array[j], ref array[j+1]);
}
}
}
}
/// <summary>
/// Validates that the specified value is less than or equal to a specified compare
/// value.
/// </summary>
/// <typeparam name="T">The type of the value being validated.</typeparam>
/// <param name="value">The value to validate is less than or equal to the specified
/// compare value.</param>
/// <param name="compareValue">The compare value to validate against.</param>
/// <param name="valueName">The name of the parameter being validated.</param>
/// <param name="comparer">The comparer to use to compare the specified values.</param>
/// <exception cref="ArgumentOutOfRangeException"><paramref name="value"/> is greater than
/// <paramref name="compareValue"/>.</exception>
public static void IsLessThanOrEqualTo <T>(
T value,
T compareValue,
string valueName,
IComparer <T> comparer)
{
if (comparer?.Compare(value, compareValue) > 0)
{
throw new ArgumentOutOfRangeException(
valueName,
Invariant($"Value must be less than or equal to {compareValue}."));
}
}
public static void SortArrayByDecrease(int[][] arr, IComparer compare)
{
for (int i = 0; i < arr.Length; i++)
{
for (int j = i + 1; j < arr.Length; j++)
{
if (compare.Compare(arr[i], arr[j]) == -1)
{
Swap(ref arr[i], ref arr[j]);
}
}
}
}
/// <summary>
/// Validates that the specified value is greater than a specified compare value.
/// </summary>
/// <typeparam name="T">The type of the value being validated.</typeparam>
/// <param name="value">The value to validate is greater than the specified compare value.
/// </param>
/// <param name="compareValue">The compare value to validate against.</param>
/// <param name="valueName">The name of the parameter being validated.</param>
/// <param name="comparer">The comparer to use to compare the specified values.</param>
/// <exception cref="ArgumentOutOfRangeException"><paramref name="value"/> is less than or
/// equal to <paramref name="compareValue"/>.</exception>
public static void IsGreaterThan <T>(
T value,
T compareValue,
string valueName,
IComparer <T> comparer)
{
if (comparer?.Compare(value, compareValue) <= 0)
{
throw new ArgumentOutOfRangeException(
valueName,
Invariant($"Value must be greater than {compareValue}."));
}
}
public static XmlNode GetOrCreateElement(XmlNode node, string xpathNotIncludingElement,
string elementName, string nameSpace, XmlNamespaceManager nameSpaceManager, IComparer<XmlNode> nodeOrderComparer)
{
//enhance: if the parent path isn't found, strip of the last piece and recurse,
//so that the path will always be created if needed.
XmlNode parentNode = node.SelectSingleNode(xpathNotIncludingElement,nameSpaceManager);
if (parentNode == null)
{
throw new ApplicationException(string.Format("The path {0} could not be found", xpathNotIncludingElement));
}
string prefix = "";
if (!String.IsNullOrEmpty(nameSpace))
{
prefix = nameSpace + ":";
}
XmlNode n = parentNode.SelectSingleNode(prefix+elementName,nameSpaceManager);
if (n == null)
{
if (!String.IsNullOrEmpty(nameSpace))
{
n = GetDocument(node).CreateElement(nameSpace, elementName, nameSpaceManager.LookupNamespace(nameSpace));
}
else
{
n = GetDocument(node).CreateElement(elementName);
}
if (nodeOrderComparer == null)
{
parentNode.AppendChild(n);
}
else
{
XmlNode insertAfterNode = null;
foreach (XmlNode childNode in parentNode.ChildNodes)
{
if (childNode.NodeType != XmlNodeType.Element)
{
continue;
}
if (nodeOrderComparer.Compare(n, childNode) < 0)
{
break;
}
insertAfterNode = childNode;
}
parentNode.InsertAfter(n, insertAfterNode);
}
}
return n;
}
public static int Compare(SortedList a, SortedList b, IComparer comparer)
{
if (a == null || b == null) {
return 1;
}
int cmp;
int limit = (a.Count < b.Count) ? a.Count : b.Count;
for(int i=0; i < limit; i++) {
if(0 != (cmp = comparer.Compare(a.GetByIndex(i), b.GetByIndex(i)))) {
return cmp;
}
}
return a.Count - b.Count;
}
// Stable insertion seort
// TODO: Should really be merge sort
public override void Sort(IComparer comparison)
{
if (comparison == null)
throw new System.ArgumentNullException( "comparison" );
int count = this.Count;
for(int j = 1; j < count; j++) {
object key = this[j];
int i = j - 1;
for (; i >= 0 && comparison.Compare(this[i], key) > 0; i--) {
this[i + 1] = this[i];
}
this[i + 1] = key;
}
}
/// <summary>
/// Can the timestamped transaction re-cache this
/// locked item now?
/// </summary>
public bool IsPuttable( long txTimestamp, object newVersion, IComparer comparator )
{
if( timeout < txTimestamp )
{
return true;
}
if( multiplicity > 0 )
{
return false;
}
return version == null ?
unlockTimestamp < txTimestamp :
comparator.Compare( version, newVersion ) < 0; //by requiring <, we rely on lock timeout in the case of an unsuccessful update!
}
/// <summary>
/// Asserts that the elements at the given index in both arrays are equal.
/// </summary>
/// <param name="comparer">An optional comparer to use.</param>
public static void AssertArrayElementsAreEqual(Array first, Array second, int index, IComparer comparer = null)
{
object firstValue = first.GetValue(index);
object secondValue = second.GetValue(index);
if (comparer != null)
{
Assert.Equal(0, comparer.Compare(firstValue, secondValue));
}
else
{
Assert.Equal(firstValue, secondValue);
}
}
public static String[] BubbleSort(String[] sourceArray, IComparer<String> Comparer)
{
for (int i = 0; i < sourceArray.Length; i++)
{
for (int j = i + 1; j < sourceArray.Length; j++)
{
if (Comparer.Compare(sourceArray[j],sourceArray[i])==-1)
{
swap(sourceArray,i,j);
}
}
}
return sourceArray;
}
//public static bool CheckMass(int[][] m)
//{
// bool b=true;
// if (m == null || m.Length == 0)
// b = false;
// else{
// for (int i = 0; i < m.Length; i++)
// {
// if (m[i] == null || m[i].Length == 0)
// b = false;
// }
// }
// return b;
//}
public static void Sort(int[][] m, IComparer<int[]> comparer)
{
if (m == null || comparer == null)
{
throw new ArgumentNullException();
}
for (int i = 0; i < m.GetLength(0)-1; i++)
{
for (int j = i + 1; j < m.GetLength(0); j++)
{
if( comparer.Compare( m[i], m[j] ) > 1)
Swap(ref m[i],ref m[j]);
}
}
}
public static void Sort(int[][] array, IComparer<int[]> comparer)
{
int iEnd = array.Length - 1;
while (0 < iEnd)
{
for (int j = 0; j < iEnd; j++)
if (comparer.Compare(array[j], array[j + 1]) > 0)
{
int[] a = array[j];
array[j] = array[j + 1];
array[j + 1] = a;
}
iEnd--;
}
}
public static int Compare(IList a, IList b, IComparer comparer)
{
if (a == null || b == null) {
return 1;
}
int limit = (a.Count < b.Count) ? a.Count : b.Count;
for(int i=0; i < limit; i++) {
if (a[i] is IComparable && b[i] is IComparable) {
int cmp = comparer.Compare(a[i], b[i]);
if (cmp != 0) {
return cmp;
}
}
}
return a.Count - b.Count;
}
public static void SortArray(int[][] arr, IComparer comparer)
{
if (comparer == null || arr == null)
throw new ArgumentNullException();
for (int i = 0; i < arr.Length; i++)
{
for (int j = i + 1; j < arr.Length; j++)
{
if (comparer.Compare(arr[i], arr[j]) == -1)
{
Swap(ref arr[i], ref arr[j]);
}
}
}
}
/**********************************************************************/
#region Constructors
/// <summary>
/// Construct a new pair from the given min and max values.
/// </summary>
/// <param name="min">The minimum value of the new range.</param>
/// <param name="max">The maximum value of the new range.</param>
/// <param name="comparer">
/// The comparer to be used for comparing the minimum and maximum values.
/// <see cref="Comparer{T}.Default"/> is used if null is given.
/// </param>
/// <exception cref="ArgumentException">Throws if min is greater than max</exception>
public MinMaxPair(T min, T max, IComparer <T> comparer = null)
{
var comparison = comparer?.Compare(min, max) ?? Comparer <T> .Default.Compare(min, max);
if (comparison > 0)
{
throw new ArgumentOutOfRangeException(nameof(max), max, $"Cannot be less than {nameof(min)}");
}
Min = min;
Max = max;
IsRange = comparison != 0;
_comparer = comparer;
_hashCode = CalculateHashCode(min, max);
}
public int Compare(BenchmarkCase x, BenchmarkCase y)
{
if (x == null && y == null)
{
return(0);
}
if (x != null && y == null)
{
return(1);
}
if (x == null)
{
return(-1);
}
return(new[]
{
paramsComparer?.Compare(x.Parameters, y.Parameters) ?? 0,
jobComparer?.Compare(x.Job, y.Job) ?? 0,
targetComparer?.Compare(x.Descriptor, y.Descriptor) ?? 0,
string.CompareOrdinal(x.DisplayInfo, y.DisplayInfo)
}.FirstOrDefault(c => c != 0));
}
private int Compare(T x, T y)
{
return(_comparer?.Compare(x, y) ?? x.CompareTo(y));
}
public int CompareTo(Node <T> other)
{
return(comparer?.Compare(Data, other.Data)
?? Data.CompareTo(other.Data));
}
int IComparer <KeyValuePair <TKey, TValue> > .Compare(KeyValuePair <TKey, TValue> x, KeyValuePair <TKey, TValue> y)
{
return(_comparer.Compare(x.Key, y.Key));
}
/// <summary>
/// Determines if the values are equal.
/// </summary>
/// <returns>
/// <c>true</c> if first is equals to the second; otherwise, <c>false</c>.
/// </returns>
/// <param name="first">The first value.</param>
/// <param name="second">The second value.</param>
/// <param name="comparer"></param>
/// <typeparam name="T">The Type of values.</typeparam>
public static bool IsEqualTo <T>(this T first, T second, IComparer <T> comparer = null)
where T : IComparable <T>
{
return((comparer?.Compare(first, second) ?? first.CompareTo(second)) == 0);
}
public PriorityQueue(IComparer <T> comp) : this((x, y) => comp.Compare(x, y))
{
}
public static bool IsLessThanOrEqualTo <T>(this T first, T second, IComparer <T> comparer)
where T : IComparable <T>
{
return((comparer?.Compare(first, second) ?? first.CompareTo(second)) <= 0);
}
public static bool IsGreaterThan <T>(this T first, T second, IComparer <T> comparer)
where T : IComparable <T>
{
return((comparer?.Compare(first, second) ?? first.CompareTo(second)) > 0);
}
/// <summary>
/// Converts a <see cref="IComparer{T}"/> to a <see cref="IEqualityComparer{T}"/>.
/// </summary>
/// <typeparam name="T">The type being compared.</typeparam>
/// <param name="comparer">The comparer.</param>
/// <returns></returns>
public static IEqualityComparer <T> ToEqualityComparer <T>(this IComparer <T> comparer)
{
return(new FunctorEqualityComparer <T>((x, y) => comparer.Compare(x, y) == 0));
}
// Method for comparing keys using the provided comparer.
private int CompareWithComparer(object x, object y)
{
return(comparer.Compare(x, y));
}
public int Compare(EmbeddedPointerIndirectionNode <TTarget> x, EmbeddedPointerIndirectionNode <TTarget> y)
{
return(_innerComparer.Compare(x.Target, y.Target));
}
/// <summary>
/// Adds a new item to the list, inserting it in its corret position.
/// </summary>
/// <param name="item">The item to insert</param>
public void Insert(T item)
{
int lower = 0;
int upper = _elements.Count - 1;
while (lower <= upper)
{
int middle = lower + (upper - lower) / 2;
int comparisonResult = _comparer == null?_comparisonFunction(item, _elements[middle]) : _comparer.Compare(item, _elements[middle]);
if (comparisonResult == 0)
{
_elements.Insert(middle, item);
return;
}
if (comparisonResult < 0)
{
upper = middle - 1;
}
else
{
lower = middle + 1;
}
}
_elements.Insert(lower, item);
}
//---------------------------------------------------------------------------------------
// Straightforward IEnumerator<T> methods.
//
internal override bool MoveNext(ref TSource currentElement, ref int currentKey)
{
Contract.Assert(m_source != null);
if (m_alreadySearched)
{
return(false);
}
// Look for the greatest element.
TSource candidate = default(TSource);
TKey candidateKey = default(TKey);
bool candidateFound = false;
try
{
int loopCount = 0; //counter to help with cancellation
TSource value = default(TSource);
TKey key = default(TKey);
while (m_source.MoveNext(ref value, ref key))
{
if ((loopCount & CancellationState.POLL_INTERVAL) == 0)
{
CancellationState.ThrowIfCanceled(m_cancellationToken);
}
// If the predicate is null or the current element satisfies it, we will remember
// it as the current partition's candidate for the last element, and move on.
if (m_predicate == null || m_predicate(value))
{
candidate = value;
candidateKey = key;
candidateFound = true;
}
loopCount++;
}
// If we found a candidate element, try to publish it, so long as it's greater.
if (candidateFound)
{
lock (m_operatorState)
{
if (m_operatorState.m_partitionId == -1 || m_keyComparer.Compare(candidateKey, m_operatorState.m_key) > 0)
{
m_operatorState.m_partitionId = m_partitionId;
m_operatorState.m_key = candidateKey;
}
}
}
}
finally
{
// No matter whether we exit due to an exception or normal completion, we must ensure
// that we signal other partitions that we have completed. Otherwise, we can cause deadlocks.
m_sharedBarrier.Signal();
}
m_alreadySearched = true;
// Only if we have a candidate do we wait.
if (m_partitionId == m_operatorState.m_partitionId)
{
m_sharedBarrier.Wait(m_cancellationToken);
// Now re-read the shared index. If it's the same as ours, we won and return true.
if (m_operatorState.m_partitionId == m_partitionId)
{
currentElement = candidate;
currentKey = 0; // 1st (and only) element, so we hardcode the output index to 0.
return(true);
}
}
// If we got here, we didn't win. Return false.
return(false);
}
/// <summary>
/// Compare left and right values
/// </summary>
/// <param name="left">The left value.</param>
/// <param name="right">The right value.</param>
/// <returns>Return a value indicating which value is larger.</returns>
private int Compare(TScore left, TScore right)
{
return(comparer?.Compare(left, right) ?? left.CompareTo(right));
}
public bool Remove(KeyValuePair <TKey, TValue> item)
{
if (root == null)
{
return(false);
}
lock (this)
{
var key = item.Key;
Node prev = null;
var c = root;
stack.Clear();
do
{
var cmp = comparer?.Compare(key, c.key) ?? key.CompareTo(c.key);
if (cmp == 0)
{
if (!item.Value.Equals(c.value))
{
return(false);
}
if (c.greater == null)
{
if (prev == null)
{
root = c.less;
}
else
{
if (prev.greater == c)
{
prev.greater = c.less;
}
else
{
prev.less = c.less;
}
}
}
else if (c.less == null)
{
if (prev == null)
{
root = c.greater;
}
else
{
if (prev.greater == c)
{
prev.greater = c.greater;
}
else
{
prev.less = c.greater;
}
}
}
else
{
var caret = c.less;
if (caret.greater != null)
{
caret.height = 0;
var pcaret = c;
while (caret.greater != null)
{
pcaret = caret;
caret = caret.greater;
caret.height = 0;
}
pcaret.greater = caret.less;
caret.greater = c.greater;
caret.less = c.less;
if (prev == null)
{
root = caret;
}
else if (prev.greater == c)
{
prev.greater = caret;
}
else
{
prev.less = caret;
}
}
else
{
caret.height = 0;
caret.greater = c.greater;
if (prev == null)
{
root = caret;
}
else if (prev.greater == c)
{
prev.greater = caret;
}
else
{
prev.less = caret;
}
}
}
while (stack.Count > 0)
{
stack.Pop().height = 0;
}
root.Balance(ref root);
return(true);
}
if (cmp > 0)
{
if (c.greater == null)
{
return(false);
}
prev = c;
stack.Push(c);
c = c.greater;
}
else
{
if (c.less == null)
{
return(false);
}
prev = c;
stack.Push(c);
c = c.less;
}
}while (true);
}
}
/// <summary>
/// Compares two objects and returns a value indicating whether one is
/// less than, equal to, or greater than the other.
/// </summary>
/// <returns>
/// Value Condition Less than zero<paramref name="x" /> is less than
/// <paramref name="y" />.Zero<paramref name="x" /> equals
/// <paramref name="y" />.Greater than zero<paramref name="x" /> is
/// greater than <paramref name="y" />.
/// </returns>
/// <param name="x">The first object to compare.</param>
/// <param name="y">The second object to compare.</param>
public int Compare(T x, T y)
{
return(-_baseComparer.Compare(x, y));
}
private static int?TryGetDesiredIndexIfGroupedWorker <TDeclarationSyntax>(
SyntaxList <TDeclarationSyntax> declarationList,
TDeclarationSyntax declaration,
IList <bool> availableIndices,
IComparer <TDeclarationSyntax> comparerWithoutNameCheck,
IComparer <TDeclarationSyntax> comparerWithNameCheck)
where TDeclarationSyntax : SyntaxNode
{
if (!declarationList.IsSorted(comparerWithoutNameCheck))
{
// Existing declarations weren't grouped. Don't try to find a location
// to this declaration into.
return(null);
}
// The list was grouped (by type, staticness, accessibility). Try to find a location
// to put the new declaration into.
var result = Array.BinarySearch(declarationList.ToArray(), declaration, comparerWithoutNameCheck);
var desiredGroupIndex = result < 0 ? ~result : result;
Debug.Assert(desiredGroupIndex >= 0);
Debug.Assert(desiredGroupIndex <= declarationList.Count);
// Now, walk forward until we hit the last member of this group.
while (desiredGroupIndex < declarationList.Count)
{
// Stop walking forward if we hit an unavailable index.
if (availableIndices != null && !availableIndices[desiredGroupIndex])
{
break;
}
if (0 != comparerWithoutNameCheck.Compare(declaration, declarationList[desiredGroupIndex]))
{
// Found the index of an item not of our group.
break;
}
desiredGroupIndex++;
}
// Now, walk backward until we find the last member with the same name
// as us. We want to keep overloads together, so we'll place ourselves
// after that member.
var currentIndex = desiredGroupIndex;
while (currentIndex > 0)
{
var previousIndex = currentIndex - 1;
// Stop walking backward if we hit an unavailable index.
if (availableIndices != null && !availableIndices[previousIndex])
{
break;
}
if (0 != comparerWithoutNameCheck.Compare(declaration, declarationList[previousIndex]))
{
// Hit the previous group of items.
break;
}
// Still in the same group. If we find something with the same name
// then place ourselves after it.
if (0 == comparerWithNameCheck.Compare(declaration, declarationList[previousIndex]))
{
// Found something with the same name. Generate after this item.
return(currentIndex);
}
currentIndex--;
}
// Couldn't find anything with our name. Just place us at the end of this group.
return(desiredGroupIndex);
}
protected override bool CanReplace(T replaced, T replacing) => (_valueComparer?.Compare(replacing, replaced) ?? 1) >= 0; // allow replacing only if new value is >= old value
public PriorityQueue(IComparer <T> comp, int capacity) : this((x, y) => comp.Compare(x, y), capacity)
{
}
protected int Compare(T x, T y)
{
return(_comparer?.Compare(x, y) ?? x.CompareTo(y));
}
/// <inheritdoc />
public int Compare(T x, T y)
{
var parentResult = _parent?.Compare(x, y) ?? 0;
return(parentResult != 0 ? parentResult : _inner(x, y));
}
protected virtual int OnCompare(int i, int j)
{
return(mComparer.Compare(InnerList[i], InnerList[j]));
}