/// <summary>
/// Compares the entire members of one array whith the other one.
/// </summary>
/// <param name="a">The array to be compared.</param>
/// <param name="b">The array to be compared with.</param>
/// <returns>Returns true if the two specified arrays of Objects are equal
/// to one another. The two arrays are considered equal if both arrays
/// contain the same number of elements, and all corresponding pairs of
/// elements in the two arrays are equal. Two objects e1 and e2 are
/// considered equal if (e1==null ? e2==null : e1.Equals(e2)). In other
/// words, the two arrays are equal if they contain the same elements in
/// the same order. Also, two array references are considered equal if
/// both are null.
/// <para/>
/// Note that if the type of <typeparam name="T"/> is a <see cref="IDictionary{TKey, TValue}"/>,
/// <see cref="IList{T}"/>, or <see cref="ISet{T}"/>, its values and any nested collection values
/// will be compared for equality as well.
/// </returns>
public static bool Equals <T>(T[] a, T[] b)
{
if (object.ReferenceEquals(a, b))
{
return(true);
}
bool isValueType = typeof(T).GetTypeInfo().IsValueType;
if (!isValueType && a == null)
{
return(b == null);
}
int length = a.Length;
if (b.Length != length)
{
return(false);
}
for (int i = 0; i < length; i++)
{
T o1 = a[i];
T o2 = b[i];
if (!(isValueType ? o1.Equals(o2) : (o1 == null ? o2 == null : Collections.Equals(o1, o2))))
{
return(false);
}
}
return(true);
}
// TODO: When diverging from Java version of Lucene, can uncomment these to adhere to best practices when overriding the Equals method and implementing IEquatable<T>.
///// <summary>Overload of the == operator, it compares a
///// <see cref="EquatableSet{T}"/> to an <see cref="IEnumerable{T}"/>
///// implementation.</summary>
///// <param name="x">The <see cref="EquatableSet{T}"/> to compare
///// against <paramref name="y"/>.</param>
///// <param name="y">The <see cref="IEnumerable{T}"/> to compare
///// against <paramref name="x"/>.</param>
///// <returns>True if the instances are equal, false otherwise.</returns>
//public static bool operator ==(EquatableSet<T> x, System.Collections.Generic.IEnumerable<T> y)
//{
// // Call Equals.
// return Equals(x, y);
//}
///// <summary>Overload of the == operator, it compares a
///// <see cref="EquatableSet{T}"/> to an <see cref="IEnumerable{T}"/>
///// implementation.</summary>
///// <param name="y">The <see cref="EquatableSet{T}"/> to compare
///// against <paramref name="x"/>.</param>
///// <param name="x">The <see cref="IEnumerable{T}"/> to compare
///// against <paramref name="y"/>.</param>
///// <returns>True if the instances are equal, false otherwise.</returns>
//public static bool operator ==(System.Collections.Generic.IEnumerable<T> x, EquatableSet<T> y)
//{
// // Call equals.
// return Equals(x, y);
//}
///// <summary>Overload of the != operator, it compares a
///// <see cref="EquatableSet{T}"/> to an <see cref="IEnumerable{T}"/>
///// implementation.</summary>
///// <param name="x">The <see cref="EquatableSet{T}"/> to compare
///// against <paramref name="y"/>.</param>
///// <param name="y">The <see cref="IEnumerable{T}"/> to compare
///// against <paramref name="x"/>.</param>
///// <returns>True if the instances are not equal, false otherwise.</returns>
//public static bool operator !=(EquatableSet<T> x, System.Collections.Generic.IEnumerable<T> y)
//{
// // Return the negative of the equals operation.
// return !(x == y);
//}
///// <summary>Overload of the != operator, it compares a
///// <see cref="EquatableSet{T}"/> to an <see cref="IEnumerable{T}"/>
///// implementation.</summary>
///// <param name="y">The <see cref="EquatableSet{T}"/> to compare
///// against <paramref name="x"/>.</param>
///// <param name="x">The <see cref="IEnumerable{T}"/> to compare
///// against <paramref name="y"/>.</param>
///// <returns>True if the instances are not equal, false otherwise.</returns>
//public static bool operator !=(System.Collections.Generic.IEnumerable<T> x, EquatableSet<T> y)
//{
// // Return the negative of the equals operation.
// return !(x == y);
//}
#endregion
#region IEquatable<T> members
/// <summary>
/// Compares this sequence to <paramref name="other"/>, returning <c>true</c> if they
/// are equal, <c>false</c> otherwise.
/// <para/>
/// The comparison takes into consideration any values in this collection and values
/// of any nested collections, but does not take into consideration the data type.
/// Therefore, <see cref="EquatableSet{T}"/> can equal any <see cref="ISet{T}"/>
/// with the exact same values (in any order).
/// </summary>
/// <param name="other">The other object
/// to compare against.</param>
/// <returns><c>true</c> if the sequence in <paramref name="other"/>
/// is the same as this one.</returns>
public virtual bool Equals(ISet <T> other)
{
return(Collections.Equals(this, other));
}