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 bool Equals(Pair <T> x, Pair <T> y)
{
if (!BaseComparer.Equals(x.First, y.First))
{
return(false);
}
return(BaseComparer.Equals(x.Second, y.Second));
}
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);
}
}
}
}
}
}
}
// 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));
}
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);
}
}
public override bool Equals(T x, T y) => BaseComparer.Equals(x, y);
public override bool Equals(T x, T y)
{
return(BaseComparer.Equals(x, y));
}
public override bool Equals(TEnum x, TEnum y)
{
return(BaseComparer.Equals(enumToSystem(x), enumToSystem(y)));
}
public override bool Equals(Pair <T> x, Pair <T> y) => BaseComparer.Equals(x.First, y.First) && BaseComparer.Equals(x.Second, y.Second);
public override bool Equals(Wrapper1 <T> x, Wrapper1 <T> y)
{
return(BaseComparer.Equals(x.Value, y.Value));
}
public override bool Equals(TEnum x, TEnum y) => BaseComparer.Equals(EnumToSystem(x), EnumToSystem(y));