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