Add operator overrides for IComparable types, #683

src/Lucene.Net.Benchmark/Quality/QualityQuery.cs

@@ -28,13 +28,13 @@ namespace Lucene.Net.Benchmarks.Quality
     /// <para/>
     /// The ID allows to map the quality query with its judgements.
     /// <para/>
-    /// The name-value pairs are used by a 
+    /// The name-value pairs are used by a
     /// <see cref="IQualityQueryParser"/>
     /// to create a Lucene <see cref="Search.Query"/>.
     /// <para/>
     /// It is very likely that name-value-pairs would be mapped into fields in a Lucene query,
     /// but it is up to the QualityQueryParser how to map - e.g. all values in a single field,
-    /// or each pair as its own field, etc., - and this of course must match the way the 
+    /// or each pair as its own field, etc., - and this of course must match the way the
     /// searched index was constructed.
     /// </summary>
     public class QualityQuery : IComparable<QualityQuery>
@@ -99,5 +99,28 @@ public virtual int CompareTo(QualityQuery other)
                 return queryID.CompareToOrdinal(other.queryID);
             }
         }
+
+        #region Operator overrides
+        // LUCENENET specific - per csharpsquid:S1210, IComparable<T> should override comparison operators
+
+        public static bool operator <(QualityQuery left, QualityQuery right)
+            => left is null ? right is not null : left.CompareTo(right) < 0;
+
+        public static bool operator <=(QualityQuery left, QualityQuery right)
+            => left is null || left.CompareTo(right) <= 0;
+
+        public static bool operator >(QualityQuery left, QualityQuery right)
+            => left is not null && left.CompareTo(right) > 0;
+
+        public static bool operator >=(QualityQuery left, QualityQuery right)
+            => left is null ? right is null : left.CompareTo(right) >= 0;
+
+        public static bool operator ==(QualityQuery left, QualityQuery right)
+            => left?.Equals(right) ?? right is null;
+
+        public static bool operator !=(QualityQuery left, QualityQuery right)
+            => !(left == right);
+
+        #endregion
     }
 }

src/Lucene.Net.Highlighter/VectorHighlight/FieldPhraseList.cs

@@ -442,7 +442,7 @@ public override int GetHashCode()
 
             public override bool Equals(object obj)
             {
-                if (this == obj)
+                if (ReferenceEquals(this, obj))
                 {
                     return true;
                 }
@@ -470,6 +470,29 @@ public override bool Equals(object obj)
                 return true;
             }
 
+            #region Operator overrides
+            // LUCENENET specific - per csharpsquid:S1210, IComparable<T> should override comparison operators
+
+            public static bool operator <(WeightedPhraseInfo left, WeightedPhraseInfo right)
+                => left is null ? right is not null : left.CompareTo(right) < 0;
+
+            public static bool operator <=(WeightedPhraseInfo left, WeightedPhraseInfo right)
+                => left is null || left.CompareTo(right) <= 0;
+
+            public static bool operator >(WeightedPhraseInfo left, WeightedPhraseInfo right)
+                => left is not null && left.CompareTo(right) > 0;
+
+            public static bool operator >=(WeightedPhraseInfo left, WeightedPhraseInfo right)
+                => left is null ? right is null : left.CompareTo(right) >= 0;
+
+            public static bool operator ==(WeightedPhraseInfo left, WeightedPhraseInfo right)
+                => left?.Equals(right) ?? right is null;
+
+            public static bool operator !=(WeightedPhraseInfo left, WeightedPhraseInfo right)
+                => !(left == right);
+
+            #endregion
+
             /// <summary>
             /// Term offsets (start + end)
             /// </summary>
@@ -512,7 +535,7 @@ public override int GetHashCode()
 
                 public override bool Equals(object obj)
                 {
-                    if (this == obj)
+                    if (ReferenceEquals(this, obj))
                     {
                         return true;
                     }
@@ -535,12 +558,36 @@ public override bool Equals(object obj)
                     }
                     return true;
                 }
+
                 public override string ToString()
                 {
                     StringBuilder sb = new StringBuilder();
                     sb.Append('(').Append(startOffset).Append(',').Append(endOffset).Append(')');
                     return sb.ToString();
                 }
+
+                #region Operator overrides
+                // LUCENENET specific - per csharpsquid:S1210, IComparable<T> should override comparison operators
+
+                public static bool operator <(Toffs left, Toffs right)
+                    => left is null ? right is not null : left.CompareTo(right) < 0;
+
+                public static bool operator <=(Toffs left, Toffs right)
+                    => left is null || left.CompareTo(right) <= 0;
+
+                public static bool operator >(Toffs left, Toffs right)
+                    => left is not null && left.CompareTo(right) > 0;
+
+                public static bool operator >=(Toffs left, Toffs right)
+                    => left is null ? right is null : left.CompareTo(right) >= 0;
+
+                public static bool operator ==(Toffs left, Toffs right)
+                    => left?.Equals(right) ?? right is null;
+
+                public static bool operator !=(Toffs left, Toffs right)
+                    => !(left == right);
+
+                #endregion
             }
         }
     }

src/Lucene.Net.Highlighter/VectorHighlight/FieldTermStack.cs

@@ -265,7 +265,7 @@ public override int GetHashCode()
 
             public override bool Equals(object obj)
             {
-                if (this == obj)
+                if (ReferenceEquals(this, obj))
                 {
                     return true;
                 }
@@ -284,6 +284,29 @@ public override bool Equals(object obj)
                 }
                 return true;
             }
+
+            #region Operator overrides
+            // LUCENENET specific - per csharpsquid:S1210, IComparable<T> should override comparison operators
+
+            public static bool operator <(TermInfo left, TermInfo right)
+                => left is null ? right is not null : left.CompareTo(right) < 0;
+
+            public static bool operator <=(TermInfo left, TermInfo right)
+                => left is null || left.CompareTo(right) <= 0;
+
+            public static bool operator >(TermInfo left, TermInfo right)
+                => left is not null && left.CompareTo(right) > 0;
+
+            public static bool operator >=(TermInfo left, TermInfo right)
+                => left is null ? right is null : left.CompareTo(right) >= 0;
+
+            public static bool operator ==(TermInfo left, TermInfo right)
+                => left?.Equals(right) ?? right is null;
+
+            public static bool operator !=(TermInfo left, TermInfo right)
+                => !(left == right);
+
+            #endregion
         }
     }
 }

src/Lucene.Net.QueryParser/Surround/Query/SimpleTerm.cs

@@ -28,8 +28,8 @@ namespace Lucene.Net.QueryParsers.Surround.Query
     public abstract class SimpleTerm : SrndQuery, IDistanceSubQuery, IComparable<SimpleTerm>
     {
         protected SimpleTerm(bool quoted) // LUCENENET: CA1012: Abstract types should not have constructors (marked protected)
-        { 
-            this.quoted = quoted; 
+        {
+            this.quoted = quoted;
         }
 
         private readonly bool quoted; // LUCENENET: marked readonly
@@ -115,5 +115,32 @@ public override Search.Query MakeLuceneQueryFieldNoBoost(string fieldName, Basic
         {
             return new SimpleTermRewriteQuery(this, fieldName, qf);
         }
+
+        #region Operator overrides
+        // LUCENENET specific - per csharpsquid:S1210, IComparable<T> should override comparison operators
+        // NOTE: The CompareTo method is marked as obsolete, but we still need to implement the comparison operators
+        // since this is public in 4.8. Suppressing the obsolete warning here.
+
+#pragma warning disable CS0618 // Type or member is obsolete
+        public static bool operator <(SimpleTerm left, SimpleTerm right)
+            => left is null ? right is not null : left.CompareTo(right) < 0;
+
+        public static bool operator <=(SimpleTerm left, SimpleTerm right)
+            => left is null || left.CompareTo(right) <= 0;
+
+        public static bool operator >(SimpleTerm left, SimpleTerm right)
+            => left is not null && left.CompareTo(right) > 0;
+
+        public static bool operator >=(SimpleTerm left, SimpleTerm right)
+            => left is null ? right is null : left.CompareTo(right) >= 0;
+#pragma warning restore CS0618 // Type or member is obsolete
+
+        public static bool operator ==(SimpleTerm left, SimpleTerm right)
+            => left?.Equals(right) ?? right is null;
+
+        public static bool operator !=(SimpleTerm left, SimpleTerm right)
+            => !(left == right);
+
+        #endregion
     }
 }

src/Lucene.Net.Spatial/Prefix/Tree/Cell.cs

@@ -28,13 +28,13 @@ namespace Lucene.Net.Spatial.Prefix.Tree
     /// <summary>
     /// Represents a grid cell. These are not necessarily thread-safe, although new
     /// Cell("") (world cell) must be.
-    /// 
+    ///
     /// @lucene.experimental
     /// </summary>
     public abstract class Cell : IComparable<Cell>
     {
         /// <summary>
-        /// LUCENENET specific - we need to set the SpatialPrefixTree before calling overridden 
+        /// LUCENENET specific - we need to set the SpatialPrefixTree before calling overridden
         /// members of this class, just in case those overridden members require it. This is
         /// not possible from the subclass because the constructor of the base class runs first.
         /// So we need to move the reference here and also set it before running the normal constructor
@@ -90,7 +90,7 @@ protected Cell(SpatialPrefixTree spatialPrefixTree, string token)
             {
                 this.token = token.Substring(0, (token.Length - 1) - 0);
                 // LUCENENET specific - calling private instead of virtual to avoid initialization issues
-                SetLeafInternal(); 
+                SetLeafInternal();
             }
             if (Level == 0)
             {
@@ -178,8 +178,8 @@ private void B_fixLeaf()
         public virtual bool IsLeaf => m_leaf;
 
         /// <summary>Note: not supported at level 0.
-        /// 
-        /// NOTE: When overriding this method, be aware that the constructor of this class calls 
+        ///
+        /// NOTE: When overriding this method, be aware that the constructor of this class calls
         /// a private method and not this virtual method. So if you need to override
         /// the behavior during the initialization, call your own private method from the constructor
         /// with whatever custom behavior you need.
@@ -232,7 +232,7 @@ public virtual byte[] GetTokenBytes()
         //public Cell getParent();
         /// <summary>
         /// Like <see cref="GetSubCells()">GetSubCells()</see> but with the results filtered by a shape. If
-        /// that shape is a <see cref="IPoint"/> then it must call 
+        /// that shape is a <see cref="IPoint"/> then it must call
         /// <see cref="GetSubCell(IPoint)"/>. The returned cells
         /// should have <see cref="ShapeRel">ShapeRel</see> set to their relation with
         /// <paramref name="shapeFilter"/>. In addition, <see cref="IsLeaf"/>
@@ -337,5 +337,27 @@ public override string ToString()
 
         #endregion
 
+        #region Operator overrides
+        // LUCENENET specific - per csharpsquid:S1210, IComparable<T> should override comparison operators
+
+        public static bool operator <(Cell? left, Cell? right)
+            => left is null ? right is not null : left.CompareTo(right) < 0;
+
+        public static bool operator <=(Cell? left, Cell? right)
+            => left is null || left.CompareTo(right) <= 0;
+
+        public static bool operator >(Cell? left, Cell? right)
+            => left is not null && left.CompareTo(right) > 0;
+
+        public static bool operator >=(Cell? left, Cell? right)
+            => left is null ? right is null : left.CompareTo(right) >= 0;
+
+        public static bool operator ==(Cell? left, Cell? right)
+            => left?.Equals(right) ?? right is null;
+
+        public static bool operator !=(Cell? left, Cell? right)
+            => !(left == right);
+
+        #endregion
     }
-}
+}

src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletion.cs

@@ -67,6 +67,29 @@ public int CompareTo(Completion o)
             {
                 return this.Utf8.CompareTo(o.Utf8);
             }
+
+            #region Operator overrides
+            // LUCENENET specific - per csharpsquid:S1210, IComparable<T> should override comparison operators
+
+            public static bool operator <(Completion left, Completion right)
+                => left is null ? right is not null : left.CompareTo(right) < 0;
+
+            public static bool operator <=(Completion left, Completion right)
+                => left is null || left.CompareTo(right) <= 0;
+
+            public static bool operator >(Completion left, Completion right)
+                => left is not null && left.CompareTo(right) > 0;
+
+            public static bool operator >=(Completion left, Completion right)
+                => left is null ? right is null : left.CompareTo(right) >= 0;
+
+            public static bool operator ==(Completion left, Completion right)
+                => left?.Equals(right) ?? right is null;
+
+            public static bool operator !=(Completion left, Completion right)
+                => !(left == right);
+
+            #endregion
         }
 
         /// <summary>

src/Lucene.Net.Suggest/Suggest/Lookup.cs

@@ -43,7 +43,7 @@ public sealed class LookupResult : IComparable<LookupResult>
 
             /// <summary>
             /// Expert: custom Object to hold the result of a
-            /// highlighted suggestion. 
+            /// highlighted suggestion.
             /// </summary>
             public object HighlightKey { get; private set; }
 
@@ -122,14 +122,37 @@ public int CompareTo(LookupResult o)
             {
                 return CHARSEQUENCE_COMPARER.Compare(Key, o.Key);
             }
+
+            #region Operator overrides
+            // LUCENENET specific - per csharpsquid:S1210, IComparable<T> should override comparison operators
+
+            public static bool operator <(LookupResult left, LookupResult right)
+                => left is null ? right is not null : left.CompareTo(right) < 0;
+
+            public static bool operator <=(LookupResult left, LookupResult right)
+                => left is null || left.CompareTo(right) <= 0;
+
+            public static bool operator >(LookupResult left, LookupResult right)
+                => left is not null && left.CompareTo(right) > 0;
+
+            public static bool operator >=(LookupResult left, LookupResult right)
+                => left is null ? right is null : left.CompareTo(right) >= 0;
+
+            public static bool operator ==(LookupResult left, LookupResult right)
+                => left?.Equals(right) ?? right is null;
+
+            public static bool operator !=(LookupResult left, LookupResult right)
+                => !(left == right);
+
+            #endregion
         }
 
         /// <summary>
         /// A simple char-by-char comparer for <see cref="string"/>
         /// </summary>
         public static readonly IComparer<string> CHARSEQUENCE_COMPARER = new CharSequenceComparer();
 
-        // LUCENENET: It is no longer good practice to use binary serialization. 
+        // LUCENENET: It is no longer good practice to use binary serialization.
         // See: https://github.com/dotnet/corefx/issues/23584#issuecomment-325724568
 #if FEATURE_SERIALIZABLE
         [Serializable]
@@ -201,7 +224,7 @@ public LookupResult[] GetResults()
         }
 
         /// <summary>
-        /// Sole constructor. (For invocation by subclass 
+        /// Sole constructor. (For invocation by subclass
         /// constructors, typically implicit.)
         /// </summary>
         protected Lookup() // LUCENENET: CA1012: Abstract types should not have constructors (marked protected)
@@ -306,4 +329,4 @@ public virtual IList<LookupResult> DoLookup(string key, bool onlyMorePopular, in
         /// <returns> ram size of the lookup implementation in bytes </returns>
         public abstract long GetSizeInBytes();
     }
-}
+}