public override bool Equals(T[] x, T[] y)
{
if (x == null)
{
if (y == null)
{
return(true);
}
return(false);
}
if (y == null)
{
return(false);
}
int r = x.Length - y.Length;
if (r != 0)
{
return(false);
}
for (int i = x.Length - 1; i >= 0; i--)
{
if (!BaseComparer.Equals(x[i], y[i]))
{
return(false);
}
}
return(true);
}
public override int Compare(Assembly x, Assembly y)
{
if (ReferenceEquals(x, y))
{
return(0);
}
if (x == null)
{
if (y == null)
{
return(0);
}
else
{
return(-DefaultDirectionMultiplier);
}
}
else
{
if (y == null)
{
return(DefaultDirectionMultiplier);
}
else
{
return(BaseComparer.Compare(x.FullName, y.FullName));
}
}
}
public override int Compare(T[] x, T[] y)
{
if (x == null)
{
return(y == null ? 0 : -DefaultDirectionMultiplier);
}
if (y == null)
{
return(DefaultDirectionMultiplier);
}
var minLength = x.Length;
var result = -minLength - 1;
if (minLength > y.Length)
{
minLength = y.Length;
result = minLength + 1;
}
for (var i = 0; i < minLength;)
{
var r = BaseComparer.Compare(x[i], y[i]);
i++;
if (r == 0)
{
continue;
}
return(r > 0 ? i : -i);
}
return(result * (int)ComparisonRules.GetDefaultRuleDirection(minLength));
}
/// <summary>
/// Processes the subsets.
/// </summary>
/// <param name="query">The query.</param>
/// <param name="resultItemList">The result item list.</param>
/// <param name="groupByResult">The GroupByResult</param>
/// <param name="baseComparer">The BaseComparer</param>
protected override void ProcessSubsets(BaseMultiIndexIdQuery <PagedIndexQueryResult> query,
ref List <ResultItem> resultItemList,
ref GroupByResult groupByResult,
BaseComparer baseComparer)
{
PagedIndexQuery pagedQuery = query as PagedIndexQuery;
if (!pagedQuery.ClientSideSubsetProcessingRequired && pagedQuery.PageNum != 0)
{
int pageSize = pagedQuery.PageSize;
int start = (pagedQuery.PageNum - 1) * pageSize;
int end = pagedQuery.PageNum * pageSize;
if (pagedQuery.GroupBy == null)
{
List <ResultItem> pageFilteredResultItemList = new List <ResultItem>();
for (int i = start; i < end && i < resultItemList.Count; i++)
{
pageFilteredResultItemList.Add(resultItemList[i]);
}
resultItemList = pageFilteredResultItemList;
}
else
{
GroupByResult pageGroupByResult = new GroupByResult(baseComparer);
for (int i = start; i < end && i < groupByResult.Count; i++)
{
pageGroupByResult.Add(groupByResult[i].CompositeKey, groupByResult[i]);
}
groupByResult = pageGroupByResult;
}
}
}
protected GroupComparer CreateGroupHeader(BaseComparer sc)
{
GroupComparer gc = new GroupComparer(sc.ColumnCollection, sc.ListIndex, sc.ObjectArray);
IndexList.Add(gc);
return(gc);
}
public void SetUp()
{
_factoryMock = Substitute.For <IComparersFactory>();
_parentComparerMock = Substitute.ForPartsOf <BaseComparer>(new ComparisonSettings(), null, _factoryMock);
_comparer =
Substitute.ForPartsOf <AbstractComparer>(new ComparisonSettings(), _parentComparerMock, _factoryMock);
}
/// <summary>
/// Processes the subsets.
/// </summary>
/// <param name="query">The query.</param>
/// <param name="resultItemList">The result item list.</param>
/// <param name="groupByResult">The group by result.</param>
/// <param name="baseComparer">The base comparer.</param>
protected override void ProcessSubsets(BaseMultiIndexIdQuery <SpanQueryResult> query,
ref List <ResultItem> resultItemList,
ref GroupByResult groupByResult,
BaseComparer baseComparer)
{
SpanQuery spanQuery = query as SpanQuery;
if (!spanQuery.ClientSideSubsetProcessingRequired && spanQuery.Span != 0)
{
if (spanQuery.GroupBy == null)
{
List <ResultItem> spanFilteredResultItemList = new List <ResultItem>();
if (resultItemList.Count >= spanQuery.Offset)
{
for (int i = spanQuery.Offset - 1; i < resultItemList.Count && spanFilteredResultItemList.Count < spanQuery.Span; i++)
{
spanFilteredResultItemList.Add(resultItemList[i]);
}
}
resultItemList = spanFilteredResultItemList;
}
else
{
GroupByResult pageGroupByResult = new GroupByResult(baseComparer);
for (int i = spanQuery.Offset - 1; i < groupByResult.Count && pageGroupByResult.Count < spanQuery.Span; i++)
{
pageGroupByResult.Add(groupByResult[i].CompositeKey, groupByResult[i]);
}
groupByResult = pageGroupByResult;
}
}
}
public override bool Equals(Pair <T> x, Pair <T> y)
{
if (!BaseComparer.Equals(x.First, y.First))
{
return(false);
}
return(BaseComparer.Equals(x.Second, y.Second));
}
static void Test()
{
//接口的逆变
IEqualityComparer <BaseClass> baseComparer = new BaseComparer();
// DerivedClass 派生自 BaseClass
// 派生程度小 的转向 派生程度大 的叫逆变
IEqualityComparer <DerivedClass> childComparer = baseComparer;
}
public static BaseComparer GetBaseComparer()
{
if (_baseComp == null)
{
_baseComp = BuildRootComparer();
}
return(_baseComp);
}
public override bool Equals(TEnumerable x, TEnumerable y)
{
if (x == null)
{
if (y == null)
{
return(true);
}
else
{
return(false);
}
}
else
{
if (y == null)
{
return(false);
}
else
{
IEnumerator <T> ex = x.GetEnumerator();
IEnumerator <T> ey = y.GetEnumerator();
while (true)
{
bool hasX = ex.MoveNext();
bool hasY = ey.MoveNext();
if (!hasX)
{
if (!hasY)
{
return(true);
}
else
{
return(false);
}
}
else
{
if (!hasY)
{
return(false);
}
else
{
if (!BaseComparer.Equals(ex.Current, ey.Current))
{
return(false);
}
}
}
}
}
}
}
private static BaseComparer BuildRootComparer()
{
_baseComp = new BaseComparer();
_baseComp.TypeComparers = new List <AbstractComparer>();
_baseComp.TypeComparers.Add(new ValueTypes(_baseComp));
_baseComp.TypeComparers.Add(new StringTypes(_baseComp));
_baseComp.TypeComparers.Add(new ArrayTypes(_baseComp));
_baseComp.TypeComparers.Add(new ComplexTypes(_baseComp));
return(_baseComp);
}
public override int Compare(Pair <T> x, Pair <T> y)
{
int result = BaseComparer.Compare(x.First, y.First);
if (result != 0)
{
return(result);
}
return(BaseComparer.Compare(x.Second, y.Second));
}
public int Compare(T x, T y)
{
var result = BaseComparer.Compare(x, y);
if (Descending)
{
result = -result;
}
return(result);
}
static string ExtractValue(BaseComparer element)
{
string val = String.Empty;
GroupColumn gc = element.ColumnCollection[0] as GroupColumn;
if (gc != null)
{
val = element.ObjectArray[0].ToString();
}
return(val);
}
public override IComparer <T> GetObjectsComparer <T>(ComparisonSettings settings = null,
BaseComparer parentComparer = null)
{
IComparer <T> comparer = base.GetObjectsComparer <T>(settings, parentComparer);
if (parentComparer == null)
{
comparer.AddComparerOverride(typeof(string), new IgnoreCaseStringsValueComparer());
}
return(comparer);
}
public override IComparer <T> GetObjectsComparer <T>(ComparisonSettings settings = null,
BaseComparer parentComparer = null)
{
if (typeof(T) != typeof(IList <FormulaItem>))
{
return(base.GetObjectsComparer <T>(settings, parentComparer));
}
var comparer = new CustomFormulaItemsComparer(settings, parentComparer, this);
return((IComparer <T>)comparer);
}
public override int GetHashCode(T[] obj)
{
if (obj == null)
{
return(0);
}
int hashCode = 0;
for (int i = 0; i < obj.Length; i++)
{
hashCode ^= BaseComparer.GetHashCode(obj[i]);
}
return(hashCode);
}
public override int GetHashCode(TEnumerable obj)
{
if (obj == null)
{
return(0);
}
int hashCode = 0;
foreach (T current in obj)
{
hashCode ^= BaseComparer.GetHashCode(current);
}
return(hashCode);
}
// Constructors
public EnumComparer(IComparerProvider provider, ComparisonRules comparisonRules)
: base(provider, comparisonRules)
{
valueToIndex = new Dictionary <TEnum, int>();
Array originalValues = Enum.GetValues(typeof(TEnum));
int valueCount = originalValues.Length;
if (valueCount < 1)
{
valueCount = 1;
values = new TEnum[] { default(TEnum) };
valueToIndex.Add(values[0], 0);
}
else
{
TEnum[] allValues = new TEnum[valueCount];
for (int i = 0; i < valueCount; i++)
{
allValues[i] = (TEnum)originalValues.GetValue(i);
}
Array.Sort <TEnum>(allValues, (x, y) => BaseComparer.Compare(enumToSystem(x), enumToSystem(y)));
for (int i = 0; i < valueCount - 1; i++)
{
int j = i + 1;
if (BaseComparer.Equals(enumToSystem(allValues[i]), enumToSystem(allValues[j])))
{
valueCount--;
Array.Copy(allValues, j, allValues, i, valueCount - i);
}
}
values = new TEnum[valueCount];
Array.Copy(allValues, values, valueCount);
string[] names = Enum.GetNames(typeof(TEnum));
for (int i = 0; i < names.Length; i++)
{
TEnum current = (TEnum)originalValues.GetValue(i);
if (!valueToIndex.ContainsKey(current))
{
valueToIndex.Add(current, Array.IndexOf(values, current));
}
}
}
maxIndex = valueCount - 1;
ValueRangeInfo = new ValueRangeInfo <TEnum>(
true, values[0],
true, values[valueCount - 1],
false, default(TEnum));
}
protected static List <BaseComparer> GenericSorter(List <BaseComparer> list)
{
BaseComparer bc = list[0];
SortColumn scc = bc.ColumnCollection[0] as SortColumn;
ListSortDirection sd = scc.SortDirection;
List <BaseComparer> lbc = null;
if (sd == ListSortDirection.Ascending)
{
lbc = list.AsQueryable().AscendingOrder().ToList();
}
else
{
lbc = list.AsQueryable().DescendingOrder().ToList();
}
return(lbc);
}
protected void CheckSettingsAndFirstRow(DataTable dt, ResultSetComparisonSettings settings)
{
if (dt.Rows.Count == 0)
{
return;
}
var dr = dt.Rows[0];
for (int i = 0; i < dr.Table.Columns.Count; i++)
{
if (!dr.IsNull(i))
{
if (settings.IsNumeric(i) && IsNumericField(dr.Table.Columns[i]))
{
continue;
}
var numericConverter = new NumericConverter();
if (settings.IsNumeric(i) && !(numericConverter.IsValid(dr[i]) || BaseComparer.IsValidInterval(dr[i])))
{
var exception = string.Format("The column with an index of {0} is expecting a numeric value but the first row of your result set contains a value '{1}' not recognized as a valid numeric value or a valid interval."
, i, dr[i].ToString());
if (numericConverter.IsValid(dr[i].ToString().Replace(",", ".")))
{
exception += " Aren't you trying to use a comma (',' ) as a decimal separator? NBi requires that the decimal separator must be a '.'.";
}
throw new ResultSetComparerException(exception);
}
if (settings.IsDateTime(i) && IsDateTimeField(dr.Table.Columns[i]))
{
return;
}
if (settings.IsDateTime(i) && !BaseComparer.IsValidDateTime(dr[i].ToString()))
{
throw new ResultSetComparerException(
string.Format("The column with an index of {0} is expecting a date & time value but the first row of your result set contains a value '{1}' not recognized as a valid date & time value."
, i, dr[i].ToString()));
}
}
}
}
public override int Compare(TEnumerable x, TEnumerable y)
{
if (x == null)
{
return(y == null ? 0 : -DefaultDirectionMultiplier);
}
else
{
if (y == null)
{
return(DefaultDirectionMultiplier);
}
else
{
var ex = x.GetEnumerator();
var ey = y.GetEnumerator();
var i = 1;
while (true)
{
var hasX = ex.MoveNext();
var hasY = ey.MoveNext();
if (!hasX)
{
return(!hasY ? 0 : -i * DefaultDirectionMultiplier);
}
else
{
if (!hasY)
{
return(i * DefaultDirectionMultiplier);
}
else
{
var r = BaseComparer.Compare(ex.Current, ey.Current);
if (r != 0)
{
return(r < 0 ? -i : i);
}
}
}
i++;
}
}
}
}
/// <summary>
/// Applies the Condition on the specified item value.
/// </summary>
/// <param name="itemValue">The item value.</param>
/// <returns></returns>
internal bool Process(byte[] itemValue)
{
bool retVal = false;
BaseComparer itemComparer = new BaseComparer(false, null, new List <SortOrder>(1)
{
new SortOrder(DataType, SortBy.ASC)
});
switch (Operation)
{
case Operation.Equals:
retVal = (ByteArrayComparerUtil.CompareByteArrays(Value, itemValue)) ? true : false;
break;
case Operation.NotEquals:
retVal = (!ByteArrayComparerUtil.CompareByteArrays(Value, itemValue)) ? true : false;
break;
case Operation.GreaterThan:
retVal = (itemComparer.Compare(Value, itemValue) < 0) ? true : false;
break;
case Operation.GreaterThanEquals:
retVal = (itemComparer.Compare(Value, itemValue) <= 0) ? true : false;
break;
case Operation.LessThan:
retVal = (itemComparer.Compare(Value, itemValue) > 0) ? true : false;
break;
case Operation.LessThanEquals:
retVal = (itemComparer.Compare(Value, itemValue) >= 0) ? true : false;
break;
case Operation.BitwiseComplement:
case Operation.BitwiseAND:
case Operation.BitwiseOR:
case Operation.BitwiseXOR:
case Operation.BitwiseShiftLeft:
case Operation.BitwiseShiftRight:
retVal = CheckBitwiseCondition(itemValue);
break;
}
return(retVal);
}
private TEnum[] BuildValues(out int valueCount)
{
var originalValues = Enum.GetValues(typeof(TEnum));
valueCount = originalValues.Length;
if (valueCount < 1)
{
valueCount = 1;
var values = new TEnum[] { default(TEnum) };
valueToIndex.Add(values[0], 0);
return(values);
}
else
{
var allValues = new TEnum[valueCount];
for (var i = 0; i < valueCount; i++)
{
allValues[i] = (TEnum)originalValues.GetValue(i);
}
Array.Sort <TEnum>(allValues, (x, y) => BaseComparer.Compare(EnumToSystem(x), EnumToSystem(y)));
for (var i = 0; i < valueCount - 1; i++)
{
var j = i + 1;
if (BaseComparer.Equals(EnumToSystem(allValues[i]), EnumToSystem(allValues[j])))
{
valueCount--;
Array.Copy(allValues, j, allValues, i, valueCount - i);
}
}
var values = new TEnum[valueCount];
Array.Copy(allValues, values, valueCount);
var names = Enum.GetNames(typeof(TEnum));
for (var i = 0; i < names.Length; i++)
{
var current = (TEnum)originalValues.GetValue(i);
if (!valueToIndex.ContainsKey(current))
{
valueToIndex.Add(current, Array.IndexOf(values, current));
}
}
return(values);
}
}
internal static void MergeItemLists(ref List<ResultItem> list1, List<ResultItem> list2, int maxMergeCount, BaseComparer baseComparer)
{
int mergedListCount = list1.Count + list2.Count;
int count1 = 0;
int count2 = 0;
if (mergedListCount > maxMergeCount)
{
mergedListCount = maxMergeCount;
}
List<ResultItem> newList = new List<ResultItem>(mergedListCount);
#region Merge until one list ends
for (int i = 0; i < mergedListCount && count1 != list1.Count && count2 != list2.Count; i++)
{
newList.Add((baseComparer.Compare(list1[count1], list2[count2]) <= 0) ?
list1[count1++] : // list1 item is greater
list2[count2++]); // list2 item is greater
}
#endregion
#region Append rest of the list1/list2 to newList
if (count1 != list1.Count && newList.Count < mergedListCount)
{
int count = list1.Count - count1;
for (int i = 0; i < count && newList.Count < mergedListCount; i++)
{
newList.Add(list1[count1++]);
}
}
else if (count2 != list2.Count && newList.Count < mergedListCount)
{
int count = list2.Count - count2;
for (int i = 0; i < count && newList.Count < mergedListCount; i++)
{
newList.Add(list2[count2++]);
}
}
#endregion
#region Update reference
list1 = newList;
#endregion
}
public override T?GetNearestValue(T?value, Direction direction)
{
if (direction == Direction.None)
{
throw Exceptions.InvalidArgument(direction, "direction");
}
if (!value.HasValue)
{
return(value);
}
if (direction != ComparisonRules.Value.Direction) // Opposite direction
{
if (BaseComparer.ValueRangeInfo.HasMinValue && Equals(value.GetValueOrDefault(), BaseComparer.ValueRangeInfo.MinValue))
{
return(null);
}
}
return(BaseComparer.GetNearestValue(value.GetValueOrDefault(), direction));
}
protected void CheckSettingsFirstRowCell(ColumnRole columnRole, ColumnType columnType, DataColumn dataColumn, object value, string[] messages)
{
var columnName = dataColumn.ColumnName;
if (!DBNull.Value.Equals(value))
{
if (columnRole != ColumnRole.Ignore)
{
if (columnType == ColumnType.Numeric && IsNumericField(dataColumn))
{
return;
}
var numericCaster = new NumericCaster();
if (columnType == ColumnType.Numeric && !(numericCaster.IsValid(value) || BaseComparer.IsValidInterval(value)))
{
var exception = string.Format(messages[0]
, columnName, value.ToString());
if (numericCaster.IsValid(value.ToString().Replace(",", ".")))
{
exception += messages[1];
}
throw new EquivalerException(exception);
}
if (columnType == ColumnType.DateTime && IsDateTimeField(dataColumn))
{
return;
}
if (columnType == ColumnType.DateTime && !BaseComparer.IsValidDateTime(value.ToString()))
{
throw new EquivalerException(
string.Format(messages[2]
, columnName, value.ToString()));
}
}
}
}
public override IComparer <T> GetObjectsComparer <T>(ComparisonSettings settings = null,
BaseComparer parentComparer = null)
{
if (typeof(T) == typeof(Person))
{
var comparer = new Comparer <Person>(settings, parentComparer, this);
//Do not compare PersonId
comparer.AddComparerOverride <Guid>(DoNotCompareValueComparer.Instance);
//Sometimes MiddleName can be skipped. Compare only if property has value.
comparer.AddComparerOverride(
() => new Person().MiddleName,
(s1, s2, parentSettings) => string.IsNullOrWhiteSpace(s1) || string.IsNullOrWhiteSpace(s2) || s1 == s2);
comparer.AddComparerOverride(
() => new Person().PhoneNumber,
new PhoneNumberComparer());
return((IComparer <T>)comparer);
}
return(base.GetObjectsComparer <T>(settings, parentComparer));
}
protected static void CreateGroupedChildren(IndexList list, BaseComparer sc)
{
list.Add(sc);
}
public override T GetNearestValue(T value, Direction direction) => (T)BaseComparer.GetNearestValue(value, direction);
/// <summary>
/// Applies the Condition on the specified item value.
/// </summary>
/// <param name="itemValue">The item value.</param>
/// <returns></returns>
internal bool Process(byte[] itemValue)
{
bool retVal = false;
BaseComparer itemComparer = new BaseComparer(false, null, new List<SortOrder>(1) { new SortOrder(DataType, SortBy.ASC) });
switch (Operation)
{
case Operation.Equals:
retVal = (ByteArrayComparerUtil.CompareByteArrays(Value, itemValue)) ? true : false;
break;
case Operation.NotEquals:
retVal = (!ByteArrayComparerUtil.CompareByteArrays(Value, itemValue)) ? true : false;
break;
case Operation.GreaterThan:
retVal = (itemComparer.Compare(Value, itemValue) < 0) ? true : false;
break;
case Operation.GreaterThanEquals:
retVal = (itemComparer.Compare(Value, itemValue) <= 0) ? true : false;
break;
case Operation.LessThan:
retVal = (itemComparer.Compare(Value, itemValue) > 0) ? true : false;
break;
case Operation.LessThanEquals:
retVal = (itemComparer.Compare(Value, itemValue) >= 0) ? true : false;
break;
case Operation.BitwiseComplement:
case Operation.BitwiseAND:
case Operation.BitwiseOR:
case Operation.BitwiseXOR:
case Operation.BitwiseShiftLeft:
case Operation.BitwiseShiftRight:
retVal = CheckBitwiseCondition(itemValue);
break;
}
return retVal;
}
static string ExtractValue(BaseComparer element)
{
string val = String.Empty;
GroupColumn gc = element.ColumnCollection[0] as GroupColumn;
if (gc != null) {
val = element.ObjectArray[0].ToString();
}
return val;
}
protected GroupComparer CreateGroupHeader (BaseComparer sc)
{
GroupComparer gc = new GroupComparer(sc.ColumnCollection,sc.ListIndex,sc.ObjectArray);
IndexList.Add(gc);
return gc;
}
protected static void CreateGroupedChildren(IndexList list,BaseComparer sc)
{
list.Add(sc);
}
