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)); }
// Constructors public PairComparer(IComparerProvider provider, ComparisonRules comparisonRules) : base(provider, comparisonRules) { Pair <T1, T2> minValue, maxValue, deltaValue; bool hasMinValue = false, hasMaxValue = false, hasDeltaValue = false; minValue = maxValue = deltaValue = new Pair <T1, T2>(default(T1), default(T2)); if (BaseComparer1.ValueRangeInfo.HasMinValue & BaseComparer2.ValueRangeInfo.HasMinValue) { minValue = new Pair <T1, T2>(BaseComparer1.ValueRangeInfo.MinValue, BaseComparer2.ValueRangeInfo.MinValue); hasMinValue = true; } if (BaseComparer1.ValueRangeInfo.HasMaxValue & BaseComparer2.ValueRangeInfo.HasMaxValue) { maxValue = new Pair <T1, T2>(BaseComparer1.ValueRangeInfo.MaxValue, BaseComparer2.ValueRangeInfo.MaxValue); hasMaxValue = true; } if (BaseComparer1.ValueRangeInfo.HasDeltaValue & BaseComparer2.ValueRangeInfo.HasDeltaValue) { deltaValue = new Pair <T1, T2>(BaseComparer1.ValueRangeInfo.DeltaValue, BaseComparer2.ValueRangeInfo.DeltaValue); hasDeltaValue = true; } ValueRangeInfo = new ValueRangeInfo <Pair <T1, T2> >(hasMinValue, minValue, hasMaxValue, maxValue, hasDeltaValue, deltaValue); }
// Constructors /// <summary> /// Initializes a new instance of this type. /// </summary> /// <param name="provider">Comparer provider this comparer is bound to.</param> /// <param name="comparisonRules">Comparison rules.</param> public WrappingComparer(IComparerProvider provider, ComparisonRules comparisonRules) : base(provider, comparisonRules) { ArgumentValidator.EnsureArgumentNotNull(provider, "provider"); BaseComparer1 = provider.GetComparer <TBase1>().ApplyRules(comparisonRules[0]); BaseComparer2 = provider.GetComparer <TBase2>().ApplyRules(comparisonRules[1]); }
// Constructors public GuidComparer(IComparerProvider provider, ComparisonRules comparisonRules) : base(provider, comparisonRules) { ValueRangeInfo = new ValueRangeInfo <Guid>( true, Guid.Empty, true, new Guid(0xFFFFFFFF, 0xFFFF, 0xFFFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF), false, Guid.Empty); }
// Constructors /// <summary> /// Initializes a new instance of this type. /// </summary> /// <param name="provider">Comparer provider this comparer is bound to.</param> /// <param name="comparisonRules">Comparison rules.</param> public AdvancedComparerBase(IComparerProvider provider, ComparisonRules comparisonRules) { ArgumentValidator.EnsureArgumentNotNull(provider, "provider"); valueRangeInfo = new ValueRangeInfo <T>( false, default(T), false, default(T), false, default(T)); this.provider = provider; ComparisonRules = comparisonRules; DefaultDirectionMultiplier = comparisonRules.Value.Direction == Direction.Negative ? -1 : 1; }
// Constructors public EnumComparer(IComparerProvider provider, ComparisonRules comparisonRules) : base(provider, comparisonRules) { valueToIndex = new Dictionary <TEnum, int>(); values = BuildValues(out var valueCount); maxIndex = valueCount - 1; ValueRangeInfo = new ValueRangeInfo <TEnum>( true, values[0], true, values[valueCount - 1], false, default(TEnum)); }
// 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 override IAdvancedComparer <Type> CreateNew(ComparisonRules rules) { return(new TypeComparer(Provider, ComparisonRules.Combine(rules))); }
protected override IAdvancedComparer <T> CreateNew(ComparisonRules rules) => new BaseComparerWrapper <T, TBase>(Provider, ComparisonRules.Combine(rules));
protected override IAdvancedComparer <TupleDescriptor> CreateNew(ComparisonRules rules) => new TupleDescriptorComparer(Provider, ComparisonRules.Combine(rules));
protected override IAdvancedComparer <ushort> CreateNew(ComparisonRules rules) { return(new UInt16Comparer(Provider, ComparisonRules.Combine(rules))); }
// Constructors public ArrayComparer(IComparerProvider provider, ComparisonRules comparisonRules) : base(provider, comparisonRules) { ValueRangeInfo = new ValueRangeInfo <T[]>(true, null, false, null, false, null); }
protected override IAdvancedComparer <Pair <T1, T2> > CreateNew(ComparisonRules rules) { return(new PairComparer <T1, T2>(Provider, ComparisonRules.Combine(rules))); }
/// <inheritdoc/> public AdvancedComparer <T> ApplyRules(ComparisonRules rules) { return(cachedComparers.GetValue(rules, (_rules, _this) => new AdvancedComparer <T>(_this.CreateNew(_rules)), this)); }
/// <summary> /// Creates new comparer of the same type, but using different comparison rules. /// </summary> /// <param name="rules">Comparison rules for the new comparer (relatively to this one).</param> /// <returns>New comparer of the same type, but using different comparison rules.</returns> protected abstract IAdvancedComparer <T> CreateNew(ComparisonRules rules);
// Constructors public EnumerableInterfaceComparer(IComparerProvider provider, ComparisonRules comparisonRules) : base(provider, comparisonRules) { ValueRangeInfo = new ValueRangeInfo <TEnumerable>(true, null, false, null, false, null); }
protected override IAdvancedComparer <TEnumerable> CreateNew(ComparisonRules rules) => new EnumerableInterfaceComparer <TEnumerable, T>(Provider, ComparisonRules.Combine(rules));
protected override IAdvancedComparer <bool> CreateNew(ComparisonRules rules) { return(new BooleanComparer(Provider, ComparisonRules.Combine(rules))); }
protected override IAdvancedComparer <T[]> CreateNew(ComparisonRules rules) { return(new ArrayComparer <T>(Provider, ComparisonRules.Combine(rules))); }
// Constructors public BooleanComparer(IComparerProvider provider, ComparisonRules comparisonRules) : base(provider, comparisonRules) { ValueRangeInfo = new ValueRangeInfo <bool>(true, false, true, true, true, true); }
// Constructors internal SystemComparer(IComparerProvider provider, ComparisonRules comparisonRules) : base(provider, comparisonRules) { }
protected override IAdvancedComparer <float> CreateNew(ComparisonRules rules) => new SingleComparer(Provider, ComparisonRules.Combine(rules));
// Constructors public UInt16Comparer(IComparerProvider provider, ComparisonRules comparisonRules) : base(provider, comparisonRules) { ValueRangeInfo = new ValueRangeInfo <ushort>(true, ushort.MinValue, true, ushort.MaxValue, true, 1); }
// Constructors public SingleComparer(IComparerProvider provider, ComparisonRules comparisonRules) : base(provider, comparisonRules) { ValueRangeInfo = new ValueRangeInfo <float>(true, float.MinValue, true, float.MaxValue, false, default(float)); }
// Constructors public TupleDescriptorComparer(IComparerProvider provider, ComparisonRules comparisonRules) : base(provider, comparisonRules) { }
protected override IAdvancedComparer <T?> CreateNew(ComparisonRules rules) { return(new NullableComparer <T>(Provider, ComparisonRules.Combine(rules))); }
// Constructors public BaseComparerWrapper(IComparerProvider provider, ComparisonRules comparisonRules) : base(provider, comparisonRules) { }
/// <inheritdoc/> protected override IAdvancedComparer <TTarget> CreateNew(ComparisonRules rules) { return(new CastingComparer <TSource, TTarget>(sourceComparer.ApplyRules(rules))); }
// Constructors public TypeComparer(IComparerProvider provider, ComparisonRules comparisonRules) : base(provider, comparisonRules) { Initialize(); }
// Constructors public SByteComparer(IComparerProvider provider, ComparisonRules comparisonRules) : base(provider, comparisonRules) { ValueRangeInfo = new ValueRangeInfo <sbyte>(true, SByte.MinValue, true, SByte.MaxValue, true, 1); }