Introduce equality comparers for OpenXmlElement

src/DocumentFormat.OpenXml.Framework/Equality/HashCode.cs

@@ -0,0 +1,31 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+namespace DocumentFormat.OpenXml
+{
+    internal ref struct HashCode
+    {
+        private const int Seed = 23;
+        private const int Combinator = 37;
+
+        private int _code;
+
+        public HashCode()
+        {
+            this._code = Seed;
+        }
+
+        internal void Add(object? value)
+        {
+            if (value != null)
+            {
+                unchecked
+                {
+                    this._code += value.GetHashCode() * Combinator;
+                }
+            }
+        }
+
+        internal readonly int GetHash => this._code;
+    }
+}

src/DocumentFormat.OpenXml.Framework/Equality/OpenXmlElementEqualityComparer.cs

@@ -0,0 +1,113 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using DocumentFormat.OpenXml.Framework;
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+
+namespace DocumentFormat.OpenXml
+{
+    internal sealed class OpenXmlElementEqualityComparer : IEqualityComparer<OpenXmlElement>
+    {
+        /// <summary>
+        /// Gets the options regulating how equality is defined.
+        /// </summary>
+        internal OpenXmlElementEqualityOptions Options { get; }
+
+        internal OpenXmlElementEqualityComparer(OpenXmlElementEqualityOptions options)
+        {
+            this.Options = options;
+        }
+
+        /// <summary>
+        /// Determines equality for two given <see cref="OpenXmlElement"/>.
+        /// </summary>
+        /// <param name="x">First object.</param>
+        /// <param name="y">Second object.</param>
+        /// <returns></returns>
+        public bool Equals(OpenXmlElement? x, OpenXmlElement? y)
+        {
+            if (ReferenceEquals(x, y))
+            {
+                return true;
+            }
+
+            if (x == null || y == null)
+            {
+                return false;
+            }
+
+            return x.ValueEquality(y, this);
+        }
+
+        /// <summary>
+        /// Calculates a hashcode based on the given <see cref="OpenXmlElement"/> object.
+        /// </summary>
+        /// <param name="obj">The object to get a hashcode for.</param>
+        /// <returns></returns>
+        public int GetHashCode([DisallowNull] OpenXmlElement obj)
+        {
+            if (obj == null)
+            {
+                return 0;
+            }
+
+            return obj.GetValueHashCode(this.Options);
+        }
+
+        internal static bool PrefixAndQNameEqual(OpenXmlElement x, OpenXmlElement y, OpenXmlElementEqualityOptions options)
+        {
+            OpenXmlQualifiedName tQName = x.ParsedState.Metadata.QName;
+            OpenXmlQualifiedName oQName = y.ParsedState.Metadata.QName;
+
+            if (!tQName.Equals(oQName))
+            {
+                return false;
+            }
+
+            if (options.SkipPrefixComparison)
+            {
+                return true;
+            }
+
+            string turi = tQName.Namespace.Uri;
+            string ouri = oQName.Namespace.Uri;
+
+            var tPrefix = x.LookupPrefixLocal(ouri);
+            var oPrefix = y.LookupPrefixLocal(ouri);
+
+            if (string.IsNullOrEmpty(tPrefix))
+            {
+               tPrefix = x.Features.GetNamespaceResolver().LookupPrefix(turi);
+            }
+
+            if (string.IsNullOrEmpty(oPrefix))
+            {
+                oPrefix = y.Features.GetNamespaceResolver().LookupPrefix(ouri);
+            }
+
+            return string.Equals(tPrefix, oPrefix, StringComparison.Ordinal);
+        }
+
+        internal static bool MoveNextAndTrackCount(ref OpenXmlElementList.Enumerator e1, ref OpenXmlElementList.Enumerator e2, ref int e1ctr, ref int e2ctr)
+        {
+            if (e1.MoveNext())
+            {
+                e1ctr++;
+                if (e2.MoveNext())
+                {
+                    e2ctr++;
+                    return true;
+                }
+            }
+            else if (e2.MoveNext())
+            {
+                e2ctr++;
+            }
+
+            return false;
+        }
+    }
+}

src/DocumentFormat.OpenXml.Framework/Equality/OpenXmlElementEqualityComparerFactory.cs

@@ -0,0 +1,28 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.Collections.Generic;
+
+namespace DocumentFormat.OpenXml
+{
+    /// <summary>
+    /// Equality comparer for determining value equality for <see cref="OpenXmlElement"/>.
+    /// </summary>
+    public static class OpenXmlElementEqualityComparerFactory
+    {
+        /// <summary>
+        /// Gets the default equality comparer.
+        /// </summary>
+        public static readonly IEqualityComparer<OpenXmlElement> Default = GetEqualityComparer(new OpenXmlElementEqualityOptions());
+
+        /// <summary>
+        /// Gets the <see cref="IEqualityComparer{OpenXmlElement}"/> based on the given options./>
+        /// </summary>
+        /// <param name="openXmlElementEqualityOptions">The options defining equality.</param>
+        /// <returns></returns>
+        public static IEqualityComparer<OpenXmlElement> GetEqualityComparer(OpenXmlElementEqualityOptions openXmlElementEqualityOptions)
+        {
+            return new OpenXmlElementEqualityComparer(openXmlElementEqualityOptions);
+        }
+    }
+}

src/DocumentFormat.OpenXml.Framework/Equality/OpenXmlElementEqualityOptions.cs

@@ -0,0 +1,31 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+namespace DocumentFormat.OpenXml
+{
+    /// <summary>
+    /// Options defining the behaviour of equality for <see cref="OpenXmlElement"/>.
+    /// </summary>
+    public sealed class OpenXmlElementEqualityOptions
+    {
+        /// <summary>
+        /// Gets or sets a value indicating whether extended attributes should be considered when determining equality.
+        /// </summary>
+        public bool IncludeExtendedAttributes { get; set; } = true;
+
+        /// <summary>
+        /// Gets or sets a value indicating whether mC attributes should be considered when determining equality.
+        /// </summary>
+        public bool IncludeMCAttributes { get; set; } = true;
+
+        /// <summary>
+        /// Gets or sets a value indicating whether namespace should alone be used when comparing idenity of elements, skipping prefix lookup to improve performance.
+        /// </summary>
+        public bool SkipPrefixComparison { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether elements must be parsed which ensures order of schema is used instead of input ordering.
+        /// </summary>
+        public bool RequireParsed { get; set; }
+    }
+}

src/DocumentFormat.OpenXml.Framework/MarkupCompatibilityAttributes.cs

@@ -1,12 +1,14 @@
 // Copyright (c) Microsoft. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+using System;
+
 namespace DocumentFormat.OpenXml
 {
     /// <summary>
     /// Defines the Markup Compatibility Attributes.
     /// </summary>
-    public class MarkupCompatibilityAttributes
+    public class MarkupCompatibilityAttributes : IEquatable<MarkupCompatibilityAttributes>
     {
         /// <summary>
         /// Gets or sets a whitespace-delimited list of prefixes, where each
@@ -42,5 +44,50 @@ public class MarkupCompatibilityAttributes
         ///  a set of namespace names.
         /// </summary>
         public StringValue? MustUnderstand { get; set; }
+
+        /// <inheritdoc/>
+        public override bool Equals(object? obj)
+        {
+            return this.Equals(obj as MarkupCompatibilityAttributes);
+        }
+
+        /// <inheritdoc/>
+        public bool Equals(MarkupCompatibilityAttributes? other)
+        {
+            if (other == null)
+            {
+                return false;
+            }
+
+            if (object.ReferenceEquals(this, other))
+            {
+                return true;
+            }
+
+            return (this.Ignorable == null == (other.Ignorable == null)) &&
+                (this.Ignorable == null || this.Ignorable.Equals(other.Ignorable)) &&
+                (this.ProcessContent == null == (other.ProcessContent == null)) &&
+                (this.ProcessContent == null || this.ProcessContent.Equals(other.ProcessContent)) &&
+                (this.PreserveElements == null == (other.PreserveElements == null)) &&
+                (this.PreserveElements == null || this.PreserveElements.Equals(other.PreserveElements)) &&
+                (this.PreserveAttributes == null == (other.PreserveAttributes == null)) &&
+                (this.PreserveAttributes == null || this.PreserveAttributes.Equals(other.PreserveAttributes)) &&
+                (this.MustUnderstand == null == (other.MustUnderstand == null)) &&
+                (this.MustUnderstand == null || this.MustUnderstand.Equals(other.MustUnderstand));
+        }
+
+        /// <inheritdoc/>
+        public override int GetHashCode()
+        {
+            var hc = default(HashCode);
+
+            hc.Add(this.Ignorable);
+            hc.Add(this.ProcessContent);
+            hc.Add(this.PreserveElements);
+            hc.Add(this.PreserveAttributes);
+            hc.Add(this.MustUnderstand);
+
+            return hc.GetHash;
+        }
     }
 }