lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nightowl...@apache.org
Subject [lucenenet] 11/20: Lucene.Net.Support.IdentityComparer: Added singleton pattern to prevent creating unnecessary instances of IdentityComparer at runtime.
Date Tue, 03 Dec 2019 14:03:41 GMT
This is an automated email from the ASF dual-hosted git repository.

nightowl888 pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/lucenenet.git

commit b56aa78f64f1ad44d1aaaeffb32d0474d74f7d47
Author: Shad Storhaug <shad@shadstorhaug.com>
AuthorDate: Fri Nov 1 13:25:14 2019 +0700

    Lucene.Net.Support.IdentityComparer: Added singleton pattern to prevent creating unnecessary
instances of IdentityComparer at runtime.
---
 src/Lucene.Net.Queries/Function/ValueSource.cs     |  2 +-
 .../Store/MockDirectoryWrapper.cs                  |  2 +-
 src/Lucene.Net/Index/SegmentCoreReaders.cs         |  2 +-
 src/Lucene.Net/Support/IdentityComparer.cs         | 40 +++++++++++++++++++++-
 src/Lucene.Net/Support/IdentityHashMap.cs          |  8 ++---
 src/Lucene.Net/Support/IdentityHashSet.cs          |  6 ++--
 6 files changed, 49 insertions(+), 11 deletions(-)

diff --git a/src/Lucene.Net.Queries/Function/ValueSource.cs b/src/Lucene.Net.Queries/Function/ValueSource.cs
index 25616b4..60d10a8 100644
--- a/src/Lucene.Net.Queries/Function/ValueSource.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSource.cs
@@ -65,7 +65,7 @@ namespace Lucene.Net.Queries.Function
         /// </summary>
         public static IDictionary NewContext(IndexSearcher searcher)
         {
-            var context = new Hashtable(new IdentityComparer());
+            var context = new Hashtable(IdentityComparer.Default);
             context["searcher"] = searcher;
             return context;
         }
diff --git a/src/Lucene.Net.TestFramework/Store/MockDirectoryWrapper.cs b/src/Lucene.Net.TestFramework/Store/MockDirectoryWrapper.cs
index 99cfdfa..bd62788 100644
--- a/src/Lucene.Net.TestFramework/Store/MockDirectoryWrapper.cs
+++ b/src/Lucene.Net.TestFramework/Store/MockDirectoryWrapper.cs
@@ -124,7 +124,7 @@ namespace Lucene.Net.Store
 
         // use this for tracking files for crash.
         // additionally: provides debugging information in case you leave one open
-        private readonly ConcurrentDictionary<IDisposable, Exception> openFileHandles
= new ConcurrentDictionary<IDisposable, Exception>(new IdentityComparer<IDisposable>());
+        private readonly ConcurrentDictionary<IDisposable, Exception> openFileHandles
= new ConcurrentDictionary<IDisposable, Exception>(IdentityComparer<IDisposable>.Default);
 
         // NOTE: we cannot initialize the Map here due to the
         // order in which our constructor actually does this
diff --git a/src/Lucene.Net/Index/SegmentCoreReaders.cs b/src/Lucene.Net/Index/SegmentCoreReaders.cs
index d6fbee2..718345d 100644
--- a/src/Lucene.Net/Index/SegmentCoreReaders.cs
+++ b/src/Lucene.Net/Index/SegmentCoreReaders.cs
@@ -112,7 +112,7 @@ namespace Lucene.Net.Index
             }
         }
 
-        private readonly ISet<ICoreDisposedListener> coreClosedListeners = new ConcurrentHashSet<ICoreDisposedListener>(new
IdentityComparer<ICoreDisposedListener>());
+        private readonly ISet<ICoreDisposedListener> coreClosedListeners = new ConcurrentHashSet<ICoreDisposedListener>(IdentityComparer<ICoreDisposedListener>.Default);
 
         internal SegmentCoreReaders(SegmentReader owner, Directory dir, SegmentCommitInfo
si, IOContext context, int termsIndexDivisor)
         {
diff --git a/src/Lucene.Net/Support/IdentityComparer.cs b/src/Lucene.Net/Support/IdentityComparer.cs
index e66c6eb..da1ed5c 100644
--- a/src/Lucene.Net/Support/IdentityComparer.cs
+++ b/src/Lucene.Net/Support/IdentityComparer.cs
@@ -21,8 +21,26 @@ namespace Lucene.Net.Support
 	 * limitations under the License.
 	 */
 
-    public class IdentityComparer<T> : IEqualityComparer<T>
+    /// <summary>
+    /// Represents a comparison operation that tests equality by reference
+    /// instead of equality by value. Basically, the comparison is done by
+    /// checking if <see cref="System.Object.ReferenceEquals(object, object)"/>
+    /// returns true rather than by calling the "Equals" function.
+    /// </summary>
+    /// <typeparam name="T">The type of object to test for reference equality. Must
be a class, not a struct.</typeparam>
+    public class IdentityComparer<T> : IEqualityComparer<T> where T : class
     {
+        /// <summary>
+        /// Gets an <see cref="IdentityComparer{T}"/> object that tests equality by
reference
+        /// instead of equality by value. Basically, the comparison is done by
+        /// checking if <see cref="System.Object.ReferenceEquals(object, object)"/>
+        /// returns true rather than by calling the "Equals" function.
+        /// </summary>
+        public static IdentityComparer<T> Default => new IdentityComparer<T>();
+
+        internal IdentityComparer()
+        { }
+
         public bool Equals(T x, T y)
         {
             return ReferenceEquals(x, y);
@@ -34,8 +52,28 @@ namespace Lucene.Net.Support
         }
     }
 
+    /// <summary>
+    /// Represents a comparison operation that tests equality by reference
+    /// instead of equality by value. Basically, the comparison is done by
+    /// checking if <see cref="System.Object.ReferenceEquals(object, object)"/>
+    /// returns true rather than by calling the "Equals" function.
+    /// <para/>
+    /// Note that the assumption is that the object is passed will be a reference type,
+    /// although it is not strictly enforced.
+    /// </summary>
     public class IdentityComparer : IEqualityComparer
     {
+        /// <summary>
+        /// Gets an <see cref="IdentityComparer{T}"/> object that tests equality by
reference
+        /// instead of equality by value. Basically, the comparison is done by
+        /// checking if <see cref="System.Object.ReferenceEquals(object, object)"/>
+        /// returns true rather than by calling the "Equals" function.
+        /// </summary>
+        public static IdentityComparer Default => new IdentityComparer();
+
+        internal IdentityComparer()
+        { }
+
         public new bool Equals(object x, object y)
         {
             return ReferenceEquals(x, y);
diff --git a/src/Lucene.Net/Support/IdentityHashMap.cs b/src/Lucene.Net/Support/IdentityHashMap.cs
index e7a381d..174b921 100644
--- a/src/Lucene.Net/Support/IdentityHashMap.cs
+++ b/src/Lucene.Net/Support/IdentityHashMap.cs
@@ -19,20 +19,20 @@ namespace Lucene.Net.Support
 	 * limitations under the License.
 	 */
 
-    public class IdentityHashMap<TKey, TValue> : HashMap<TKey, TValue>
+    public class IdentityHashMap<TKey, TValue> : HashMap<TKey, TValue> where
TKey : class
     {
         public IdentityHashMap()
-            : base(new IdentityComparer<TKey>())
+            : base(IdentityComparer<TKey>.Default)
         {
         }
 
         public IdentityHashMap(int initialCapacity)
-            : base(initialCapacity, new IdentityComparer<TKey>())
+            : base(initialCapacity, IdentityComparer<TKey>.Default)
         {
         }
 
         public IdentityHashMap(IDictionary<TKey, TValue> wrappedDictionary)
-            : base(wrappedDictionary, new IdentityComparer<TKey>())
+            : base(wrappedDictionary, IdentityComparer<TKey>.Default)
         {
         }
     }
diff --git a/src/Lucene.Net/Support/IdentityHashSet.cs b/src/Lucene.Net/Support/IdentityHashSet.cs
index 06709c0..5695b65 100644
--- a/src/Lucene.Net/Support/IdentityHashSet.cs
+++ b/src/Lucene.Net/Support/IdentityHashSet.cs
@@ -19,15 +19,15 @@ namespace Lucene.Net.Support
 	 * limitations under the License.
 	 */
 
-    public class IdentityHashSet<T> : HashSet<T>
+    public class IdentityHashSet<T> : HashSet<T> where T : class
     {
         public IdentityHashSet()
-            : base(new IdentityComparer<T>())
+            : base(IdentityComparer<T>.Default)
         {
         }
 
         public IdentityHashSet(IEnumerable<T> collection)
-            : base(collection, new IdentityComparer<T>())
+            : base(collection, IdentityComparer<T>.Default)
         {
         }
     }


Mime
View raw message