public override bool Equals(
object x,
object y,
MemberSettings settings,
ReferencePairCollection referencePairs)
{
if (TryGetEitherNullEquals(x, y, out var result))
{
return(result);
}
var xl = (IList <T>)x;
var yl = (IList <T>)y;
if (xl.Count != yl.Count)
{
return(false);
}
var isEquatable = settings.IsEquatable(typeof(T));
if (!typeof(T).IsValueType &&
settings.ReferenceHandling == ReferenceHandling.References)
{
return(isEquatable
? ItemsEquals(xl, yl, EqualityComparer <T> .Default.Equals)
: ItemsEquals(xl, yl, (xi, yi) => ReferenceEquals(xi, yi)));
}
return(isEquatable
? ItemsEquals(xl, yl, EqualityComparer <T> .Default.Equals)
: Equals(xl, yl, settings, referencePairs));
}
/// <inheritdoc />
public override bool Equals(
object x,
object y,
MemberSettings settings,
ReferencePairCollection referencePairs)
{
bool result;
if (TryGetEitherNullEquals(x, y, out result))
{
return(result);
}
var xd = (IReadOnlyDictionary <TKey, TValue>)x;
var yd = (IReadOnlyDictionary <TKey, TValue>)y;
if (xd.Count != yd.Count)
{
return(false);
}
if (settings.IsEquatable(typeof(TValue)))
{
return(KeysAndValuesEquals(xd, yd, EqualityComparer <TValue> .Default.Equals));
}
if (settings.ReferenceHandling == ReferenceHandling.References)
{
return(KeysAndValuesEquals(xd, yd, (xi, yi) => ReferenceEquals(xi, yi)));
}
return(KeysAndValuesEquals(xd, yd, settings, referencePairs));
}
/// <inheritdoc />
public override bool Equals(
object x,
object y,
MemberSettings settings,
ReferencePairCollection referencePairs)
{
bool result;
if (TryGetEitherNullEquals(x, y, out result))
{
return(result);
}
var isEquatable = settings.IsEquatable(typeof(T));
if (settings.ReferenceHandling == ReferenceHandling.References)
{
return(isEquatable
? ItemsEquals((IEnumerable <T>)x, (IEnumerable <T>)y, EqualityComparer <T> .Default.Equals)
: ItemsEquals((IEnumerable <T>)x, (IEnumerable <T>)y, (xi, yi) => ReferenceEquals(xi, yi)));
}
return(isEquatable
? ItemsEquals((IEnumerable <T>)x, (IEnumerable <T>)y, EqualityComparer <T> .Default.Equals)
: ItemsEquals((IEnumerable <T>)x, (IEnumerable <T>)y, (xi, yi) => EqualBy.MemberValues(xi, yi, settings, referencePairs)));
}
internal static bool TryGetValueEquals <T>(T x, T y, MemberSettings settings, out bool result)
{
if (ReferenceEquals(x, y))
{
result = true;
return(true);
}
if (x == null || y == null)
{
result = false;
return(true);
}
if (x.GetType() != y.GetType())
{
result = false;
return(true);
}
if (settings.TryGetComparer(x.GetType(), out var comparer))
{
result = comparer.Equals(x, y);
return(true);
}
if (settings.IsEquatable(x.GetType()))
{
result = Equals(x, y);
return(true);
}
result = false;
return(false);
}
private static TypeErrors CreateErrors(Type type, MemberSettings settings, MemberPath path)
{
if (settings.IsEquatable(type) || settings.TryGetComparer(type, out _))
{
return(null);
}
var errors = VerifyCore(settings, type)
.VerifyRecursive(type, settings, path, GetNodeErrors)
.Finnish();
return(errors);
}
/// <inheritdoc />
public override bool Equals(
object x,
object y,
MemberSettings settings,
ReferencePairCollection referencePairs)
{
bool result;
if (TryGetEitherNullEquals(x, y, out result))
{
return(result);
}
var xs = (ISet <T>)x;
var ys = (ISet <T>)y;
if (xs.Count != ys.Count)
{
return(false);
}
var isEquatable = settings.IsEquatable(x.GetType().GetItemType());
var xHashSet = xs as HashSet <T>;
if (isEquatable)
{
if (Equals(xHashSet?.Comparer, EqualityComparer <T> .Default))
{
return(xs.SetEquals(ys));
}
return(this.ItemsEquals(xs, ys, EqualityComparer <T> .Default.Equals, EqualityComparer <T> .Default.GetHashCode));
}
if (settings.ReferenceHandling == ReferenceHandling.References)
{
return(this.ItemsEquals(xs, ys, (xi, yi) => ReferenceEquals(xi, yi), xi => RuntimeHelpers.GetHashCode(xi)));
}
var hashCodeMethod = typeof(T).GetMethod(nameof(this.GetHashCode), new Type[0]);
if (hashCodeMethod.DeclaringType == typeof(object))
{
return(this.ItemsEquals(xs, ys, (xi, yi) => EqualBy.MemberValues(xi, yi, settings, referencePairs), _ => 0));
}
return(this.ItemsEquals(xs, ys, (xi, yi) => EqualBy.MemberValues(xi, yi, settings, referencePairs), xi => xi.GetHashCode()));
}
private static bool Equals(
Array x,
Array y,
MemberSettings settings,
ReferencePairCollection referencePairs)
{
if (!Is.SameSize(x, y))
{
return false;
}
var isEquatable = settings.IsEquatable(x.GetType().GetItemType());
if (settings.ReferenceHandling == ReferenceHandling.References)
{
return isEquatable
? ItemsEquals(x, y, Equals)
: ItemsEquals(x, y, ReferenceEquals);
}
return isEquatable
? ItemsEquals(x, y, Equals)
: ItemsEquals(x, y, (xi, yi) => EqualBy.MemberValues(xi, yi, settings, referencePairs));
}
private static bool Equals(
Array x,
Array y,
MemberSettings settings,
ReferencePairCollection referencePairs)
{
if (!Is.SameSize(x, y))
{
return(false);
}
var isEquatable = settings.IsEquatable(x.GetType().GetItemType());
if (settings.ReferenceHandling == ReferenceHandling.References)
{
return(isEquatable
? ItemsEquals(x, y, Equals)
: ItemsEquals(x, y, ReferenceEquals));
}
return(isEquatable
? ItemsEquals(x, y, Equals)
: ItemsEquals(x, y, (xi, yi) => EqualBy.MemberValues(xi, yi, settings, referencePairs)));
}
private static ErrorBuilder.TypeErrorsBuilder VerifyCore(MemberSettings settings, Type type)
{
return(ErrorBuilder.Start()
.CheckRequiresReferenceHandling(type, settings, t => !settings.IsEquatable(t))
.CheckIndexers(type, settings));
}
