Use ReferenceEquals to avoid infinite recursion

Fix InlineImageDataToken not checking Data length before comparing bytes
Use a more straightforward compare Dictionary Content

src/UglyToad.PdfPig.Tokens/ArrayToken.cs

@@ -92,19 +92,27 @@
         /// <inheritdoc />
         public bool Equals(IToken obj)
         {
-            if (this == obj)
+            if (ReferenceEquals(this, obj))
+            {
                 return true;
+            }
 
             if (!(obj is ArrayToken other))
+            {
                 return false;
+            }
 
             if (other.Length != Length)
+            {
                 return false;
+            }
 
             for (var index = 0; index < Length; ++index)
             {
                 if (!Data[index].Equals(other[index]))
+                {
                     return false;
+                }
             }
 
             return true;

src/UglyToad.PdfPig.Tokens/BooleanToken.cs

@@ -44,8 +44,10 @@
         /// <inheritdoc />
         public bool Equals(IToken obj)
         {
-            if (this == obj)
+            if (ReferenceEquals(this, obj))
+            {
                 return true;
+            }
 
             if (!(obj is BooleanToken other))
             {

src/UglyToad.PdfPig.Tokens/CommentToken.cs

@@ -29,6 +29,11 @@
         /// <inheritdoc />
         public bool Equals(IToken obj)
         {
+            if (ReferenceEquals(this, obj))
+            {
+                return true;
+            }
+
             if (!(obj is CommentToken other))
             {
                 return false;

src/UglyToad.PdfPig.Tokens/DictionaryToken.cs

@@ -118,8 +118,10 @@
         /// <inheritdoc />
         public bool Equals(IToken obj)
         {
-            if (this == obj)
+            if (ReferenceEquals(this, obj))
+            {
                 return true;
+            }
 
             if (!(obj is DictionaryToken other))
             {
@@ -127,11 +129,19 @@
             }
 
             if (Data.Count != other.Data.Count)
+            {
                 return false;
+            }
 
-            // TODO: Maybe consider using a sorted dictionary?
+            foreach (var kvp in other.Data)
-            return Data.OrderBy(kvp => kvp.Key)
+            {
-           .SequenceEqual(other.Data.OrderBy(kvp => kvp.Key));
+                if (!Data.TryGetValue(kvp.Key, out var val) || !val.Equals(kvp.Value))
+                {
+                    return false;
+                }
+            }
+
+            return true;
         }
 
         /// <inheritdoc />

src/UglyToad.PdfPig.Tokens/EndOfLineToken.cs

@@ -17,15 +17,12 @@
         /// <inheritdoc />
         public bool Equals(IToken obj)
         {
-            if (this == obj)
+            if (ReferenceEquals(this, obj))
-                return true;
-
-            if (!(obj is EndOfLineToken other))
             {
-                return false;
+                return true;
             }
 
-            return true;
+            return obj is EndOfLineToken;
         }
     }
 }

src/UglyToad.PdfPig.Tokens/HexToken.cs

@@ -141,8 +141,10 @@ namespace UglyToad.PdfPig.Tokens
         /// <inheritdoc />
         public bool Equals(IToken obj)
         {
-            if (this == obj)
+            if (ReferenceEquals(this, obj))
+            {
                 return true;
+            }
 
             if (!(obj is HexToken other))
             {

src/UglyToad.PdfPig.Tokens/IndirectReferenceToken.cs

@@ -24,8 +24,10 @@
         /// <inheritdoc />
         public bool Equals(IToken obj)
         {
-            if (this == obj)
+            if (ReferenceEquals(this, obj))
+            {
                 return true;
+            }
 
             if (!(obj is IndirectReferenceToken other))
             {

src/UglyToad.PdfPig.Tokens/InlineImageDataToken.cs

@@ -22,8 +22,10 @@
         /// <inheritdoc />
         public bool Equals(IToken obj)
         {
-            if (this == obj)
+            if (ReferenceEquals(this, obj))
+            {
                 return true;
+            }
 
             if (!(obj is InlineImageDataToken other))
             {
@@ -31,14 +33,17 @@
             }
 
             if (Data.Count != other.Data.Count)
+            {
                 return false;
+            }
+
 
-            // Note: This maybe slow?
-            // Maybe pre calculate some sort of hash and compare that?
             for (var index = 0; index < Data.Count; ++index)
             {
                 if (Data[index] != other.Data[index])
+                {
                     return false;
+                }
             }
 
             return true;

src/UglyToad.PdfPig.Tokens/NumericToken.cs

@@ -109,8 +109,10 @@
         /// <inheritdoc />
         public bool Equals(IToken obj)
         {
-            if (this == obj)
+            if (ReferenceEquals(this, obj))
+            {
                 return true;
+            }
 
             if (!(obj is NumericToken other))
             {

src/UglyToad.PdfPig.Tokens/ObjectToken.cs

@@ -40,34 +40,17 @@
         /// <inheritdoc />
         public bool Equals(IToken obj)
         {
-            if (this == obj)
+            if (ReferenceEquals(this, obj))
+            {
                 return true;
+            }
 
             if (!(obj is ObjectToken other))
             {
                 return false;
             }
 
-            // I don't think we should compare this value...
+            return Number.Equals(other.Number) && Data.Equals(other.Data);
-            // If this values are the same but this object are not the same (reference)
-            // It means that one of the obj is not from stream or one of the object have been overwritten
-            // So maybe putting an assert instead, would be a good idea?
-            if (Position != other.Position)
-            {
-                return false;
-            }
-
-            if (!Number.Equals(other.Number))
-            {
-                return false;
-            }
-
-            if (!Data.Equals(other.Data))
-            {
-                return false;
-            }
-
-            return true;
         }
 
         /// <inheritdoc />

src/UglyToad.PdfPig.Tokens/OperatorToken.cs

@@ -198,8 +198,10 @@
         /// <inheritdoc />
         public bool Equals(IToken obj)
         {
-            if (this == obj)
+            if (ReferenceEquals(this, obj))
+            {
                 return true;
+            }
 
             if (!(obj is OperatorToken other))
             {

src/UglyToad.PdfPig.Tokens/StreamToken.cs

@@ -33,8 +33,10 @@
         /// <inheritdoc />
         public bool Equals(IToken obj)
         {
-            if (this == obj)
+            if (ReferenceEquals(this, obj))
+            {
                 return true;
+            }
 
             if (!(obj is StreamToken other))
             {
@@ -46,12 +48,17 @@
                 return false;
             }
 
-            // Note: This maybe slow?
+            if (Data.Count != other.Data.Count)
-            // Maybe pre calculate some sort of hash and compare that?
+            {
+                return false;
+            }
+
             for (var index = 0; index < Data.Count; ++index)
             {
                 if (Data[index] != other.Data[index])
+                {
                     return false;
+                }
             }
 
             return true;

src/UglyToad.PdfPig.Tokens/StringToken.cs

@@ -61,20 +61,17 @@ namespace UglyToad.PdfPig.Tokens
         /// <inheritdoc />
         public bool Equals(IToken obj)
         {
-            if (this == obj)
+            if (ReferenceEquals(this, obj))
+            {
                 return true;
+            }
 
             if (!(obj is StringToken other))
             {
                 return false;
             }
 
-            if (!EncodedWith.Equals(other.EncodedWith))
+            return EncodedWith.Equals(other.EncodedWith) && Data.Equals(other.Data);
-            {
-                return false;
-            }
-
-            return Data.Equals(other.Data);
         }
 
         /// <inheritdoc />