Refactor to remove wrapping types and add back non-generic interfaces for collectors

Author: paulirwin

src/Lucene.Net.Grouping/AbstractAllGroupsCollector.cs

@@ -1,4 +1,5 @@
 using Lucene.Net.Index;
+using Lucene.Net.Support;
 using System.Collections.Generic;
 
 namespace Lucene.Net.Search.Grouping
@@ -34,7 +35,7 @@ namespace Lucene.Net.Search.Grouping
     /// </summary>
     /// <typeparam name="TGroupValue"></typeparam>
     // ReSharper disable once RedundantExtendsListEntry
-    public abstract class AbstractAllGroupsCollector<TGroupValue> : ICollector
+    public abstract class AbstractAllGroupsCollector<TGroupValue> : IAbstractAllGroupsCollector
     {
         /// <summary>
         /// Returns the total number of groups for the executed search.
@@ -88,5 +89,31 @@ public virtual void SetScorer(Scorer scorer)
         public abstract void SetNextReader(AtomicReaderContext context);
 
         public virtual bool AcceptsDocsOutOfOrder => true;
+
+        #region Explicit interface implementations
+
+        ICollection<object> IAbstractAllGroupsCollector.Groups => new CastingCollectionAdapter<TGroupValue, object>(Groups);
+
+        #endregion
+    }
+
+    /// <summary>
+    /// LUCENENET specific interface to provide a non-generic abstraction
+    /// for <see cref="AbstractAllGroupsCollector{TGroupValue}"/>.
+    /// </summary>
+    public interface IAbstractAllGroupsCollector : ICollector
+    {
+        /// <summary>
+        /// Returns the total number of groups for the executed search.
+        /// </summary>
+        int GroupCount { get; }
+
+        /// <summary>
+        /// Returns the group values
+        /// <para />
+        /// This is an unordered collections of group values. For each group that matched the query there is a <see cref="Util.BytesRef"/>
+        /// representing a group value.
+        /// </summary>
+        ICollection<object> Groups { get; }
     }
 }

src/Lucene.Net.Grouping/AbstractDistinctValuesCollector.cs

@@ -1,4 +1,5 @@
 using Lucene.Net.Index;
+using Lucene.Net.Support;
 using System.Collections.Generic;
 using JCG = J2N.Collections.Generic;
 
@@ -32,7 +33,7 @@ namespace Lucene.Net.Search.Grouping
     /// The <typeparamref name="TGroupValue"/> type parameter is LUCENENET specific to allow for
     /// strongly-typed group values.
     /// </remarks>
-    public abstract class AbstractDistinctValuesCollector<GC, TGroupValue> : ICollector
+    public abstract class AbstractDistinctValuesCollector<GC, TGroupValue> : IAbstractDistinctValuesCollector
         where GC : AbstractDistinctValuesCollector.GroupCount<TGroupValue>
     {
         /// <summary>
@@ -74,6 +75,16 @@ public virtual void SetScorer(Scorer scorer)
         /// </summary>
         /// <param name="context">next atomic reader context </param>
         public abstract void SetNextReader(AtomicReaderContext context);
+
+        #region Explicit interface implementations
+
+        /// <summary>
+        /// LUCENENET specific implementation to provide a non-generic abstraction
+        /// </summary>
+        IList<AbstractDistinctValuesCollector.IGroupCount> IAbstractDistinctValuesCollector.Groups
+            => new CastingListAdapter<GC, AbstractDistinctValuesCollector.IGroupCount>(Groups);
+
+        #endregion
     }
 
     /// <summary>
@@ -93,7 +104,7 @@ public static class AbstractDistinctValuesCollector // LUCENENET specific: CA105
         /// LUCENENET - removed this class from being a nested class of
         /// <see cref="AbstractDistinctValuesCollector{GC, TGroupValue}"/>
         /// </remarks>
-        public abstract class GroupCount<TGroupValue>
+        public abstract class GroupCount<TGroupValue> : IGroupCount
         {
             public TGroupValue GroupValue { get; protected set; }
             public ISet<TGroupValue> UniqueValues { get; protected set; }
@@ -103,6 +114,37 @@ protected GroupCount(TGroupValue groupValue) // LUCENENET: CA1012: Abstract type
                 this.GroupValue = groupValue;
                 this.UniqueValues = new JCG.HashSet<TGroupValue>();
             }
+
+            #region Explicit interface implementations
+
+            object IGroupCount.GroupValue => GroupValue;
+
+            ISet<object> IGroupCount.UniqueValues => new CastingSetAdapter<TGroupValue, object>(UniqueValues);
+
+            #endregion
         }
+
+        /// <summary>
+        /// LUCENENET specific interface to provide a non-generic abstraction
+        /// for <see cref="GroupCount{TGroupValue}"/>.
+        /// </summary>
+        public interface IGroupCount
+        {
+            object GroupValue { get; }
+
+            ISet<object> UniqueValues { get; }
+        }
+    }
+
+    /// <summary>
+    /// LUCENENET specific interface to provide a non-generic abstraction
+    /// for <see cref="AbstractDistinctValuesCollector{GC, TGroupValue}"/>.
+    /// </summary>
+    public interface IAbstractDistinctValuesCollector : ICollector
+    {
+        /// <summary>
+        /// Returns all unique values for each top N group.
+        /// </summary>
+        IList<AbstractDistinctValuesCollector.IGroupCount> Groups { get; }
     }
 }

src/Lucene.Net.Grouping/AbstractFirstPassGroupingCollector.cs

@@ -1,5 +1,6 @@
 using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
+using Lucene.Net.Support;
 using Lucene.Net.Support.Threading;
 using System;
 using System.Collections.Generic;
@@ -39,7 +40,7 @@ namespace Lucene.Net.Search.Grouping
     /// @lucene.experimental
     /// </summary>
     /// <typeparam name="TGroupValue"></typeparam>
-    public abstract class AbstractFirstPassGroupingCollector<TGroupValue> : ICollector
+    public abstract class AbstractFirstPassGroupingCollector<TGroupValue> : IAbstractFirstPassGroupingCollector
     {
         private readonly Sort groupSort;
         private readonly FieldComparer[] comparers;
@@ -419,5 +420,29 @@ public virtual void SetNextReader(AtomicReaderContext context)
         /// <param name="reuse">Optionally a reuse instance to prevent a new instance creation</param>
         /// <returns>a copy of the specified group value</returns>
         protected abstract TGroupValue CopyDocGroupValue(TGroupValue groupValue, TGroupValue reuse);
+
+        #region Explicit interface implementations
+
+        ICollection<ISearchGroup> IAbstractFirstPassGroupingCollector.GetTopGroups(int groupOffset, bool fillFields)
+            => new CastingCollectionAdapter<SearchGroup<TGroupValue>, ISearchGroup>(GetTopGroups(groupOffset, fillFields));
+
+        #endregion
+    }
+
+    /// <summary>
+    /// LUCENENET specific interface to provide a non-generic abstraction
+    /// for <see cref="AbstractFirstPassGroupingCollector{TGroupValue}"/>.
+    /// </summary>
+    public interface IAbstractFirstPassGroupingCollector : ICollector
+    {
+        /// <summary>
+        /// Returns top groups, starting from offset.  This may
+        /// return null, if no groups were collected, or if the
+        /// number of unique groups collected is &lt;= offset.
+        /// </summary>
+        /// <param name="groupOffset">The offset in the collected groups</param>
+        /// <param name="fillFields">Whether to fill to <see cref="ISearchGroup.SortValues"/></param>
+        /// <returns>top groups, starting from offset</returns>
+        ICollection<ISearchGroup> GetTopGroups(int groupOffset, bool fillFields);
     }
 }

src/Lucene.Net.Grouping/AbstractSecondPassGroupingCollector.cs

@@ -36,7 +36,7 @@ namespace Lucene.Net.Search.Grouping
     /// @lucene.experimental
     /// </summary>
     /// <typeparam name="TGroupValue"></typeparam>
-    public abstract class AbstractSecondPassGroupingCollector<TGroupValue> : ICollector
+    public abstract class AbstractSecondPassGroupingCollector<TGroupValue> : IAbstractSecondPassGroupingCollector
     {
         protected readonly IDictionary<TGroupValue, AbstractSecondPassGroupingCollector.SearchGroupDocs<TGroupValue>> m_groupMap;
         private readonly int maxDocsPerGroup;
@@ -146,7 +146,12 @@ public virtual TopGroups<TGroupValue> GetTopGroups(int withinGroupOffset)
         }
 
 
+        #region Explicit interface implementations
 
+        ITopGroups IAbstractSecondPassGroupingCollector.GetTopGroups(int withinGroupOffset)
+            => GetTopGroups(withinGroupOffset);
+
+        #endregion
     }
 
     /// <summary>
@@ -173,4 +178,13 @@ public SearchGroupDocs(TGroupValue groupValue, ITopDocsCollector collector)
             }
         }
     }
+
+    /// <summary>
+    /// LUCENENET specific interface to provide a non-generic abstraction
+    /// for <see cref="AbstractSecondPassGroupingCollector{TGroupValue}"/>.
+    /// </summary>
+    public interface IAbstractSecondPassGroupingCollector : ICollector
+    {
+        ITopGroups GetTopGroups(int withinGroupOffset);
+    }
 }

src/Lucene.Net.Grouping/GroupDocs.cs

@@ -25,7 +25,7 @@ namespace Lucene.Net.Search.Grouping
     ///
     /// @lucene.experimental
     /// </summary>
-    public class GroupDocs<TGroupValue>
+    public class GroupDocs<TGroupValue> : IGroupDocs
     {
         /// <summary>
         /// The groupField value for all docs in this group; this
@@ -72,5 +72,30 @@ public GroupDocs(float score, float maxScore, int totalHits, ScoreDoc[] scoreDoc
             GroupValue = groupValue;
             GroupSortValues = groupSortValues;
         }
+
+        #region Explicit interface implementations
+
+        object IGroupDocs.GroupValue => GroupValue;
+
+        #endregion
+    }
+
+    /// <summary>
+    /// LUCENENET specific interface to provide a non-generic abstraction
+    /// for <see cref="GroupDocs{TGroupValue}"/>.
+    /// </summary>
+    public interface IGroupDocs
+    {
+        object GroupValue { get; }
+
+        float MaxScore { get; }
+
+        float Score { get; }
+
+        ScoreDoc[] ScoreDocs { get; }
+
+        int TotalHits { get; }
+
+        object[] GroupSortValues { get; }
     }
 }

src/Lucene.Net.Grouping/SearchGroup.cs

@@ -30,7 +30,7 @@ namespace Lucene.Net.Search.Grouping
     /// @lucene.experimental
     /// </summary>
     /// <typeparam name="TGroupValue"></typeparam>
-    public class SearchGroup<TGroupValue>
+    public class SearchGroup<TGroupValue> : ISearchGroup
     {
         /// <summary>
         /// The value that defines this group
@@ -79,6 +79,16 @@ public override int GetHashCode()
         {
             return GroupValue != null ? GroupValue.GetHashCode() : 0;
         }
+
+        #region Explicit interface implementations
+
+        object ISearchGroup.GroupValue
+        {
+            get => GroupValue;
+            set => GroupValue = (TGroupValue)value;
+        }
+
+        #endregion
     }
 
     /// <summary>
@@ -473,4 +483,15 @@ public static ICollection<SearchGroup<T>> Merge<T>(IList<ICollection<SearchGroup
             }
         }
     }
+
+    /// <summary>
+    /// LUCENENET specific interface to provide a non-generic abstraction
+    /// for <see cref="SearchGroup{TGroupValue}"/>.
+    /// </summary>
+    public interface ISearchGroup
+    {
+        object GroupValue { get; set; }
+
+        object[] SortValues { get; set; }
+    }
 }

src/Lucene.Net.Grouping/TopGroups.cs

@@ -1,6 +1,7 @@
 using J2N.Collections;
 using Lucene.Net.Support;
 using System;
+using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 
 namespace Lucene.Net.Search.Grouping
@@ -27,7 +28,7 @@ namespace Lucene.Net.Search.Grouping
     ///
     /// @lucene.experimental
     /// </summary>
-    public class TopGroups<TGroupValue>
+    public class TopGroups<TGroupValue> : ITopGroups
     {
         /// <summary>
         /// Number of documents matching the search </summary>
@@ -86,6 +87,12 @@ public TopGroups(TopGroups<TGroupValue> oldTopGroups, int? totalGroupCount)
             MaxScore = oldTopGroups.MaxScore;
             TotalGroupCount = totalGroupCount;
         }
+
+        #region Explicit interface implementations
+
+        IList<IGroupDocs> ITopGroups.Groups => new CastingListAdapter<GroupDocs<TGroupValue>, IGroupDocs>(Groups);
+
+        #endregion
     }
 
     /// <summary>
@@ -267,4 +274,30 @@ public static TopGroups<T> Merge<T>(TopGroups<T>[] shardGroups, Sort groupSort,
             return new TopGroups<T>(groupSort.GetSort(), docSort?.GetSort(), totalHitCount, totalGroupedHitCount, mergedGroupDocs, totalMaxScore);
         }
     }
+
+    /// <summary>
+    /// LUCENENET specific interface to provide a non-generic abstraction
+    /// for <see cref="TopGroups{TGroupValue}"/>.
+    /// </summary>
+    public interface ITopGroups
+    {
+        int TotalHitCount { get; }
+
+        int TotalGroupedHitCount { get; }
+
+        int? TotalGroupCount { get; }
+
+        /// <summary>
+        /// LUCENENET specific - this uses IList instead of an array
+        /// as it would require a new array to be created each time
+        /// the property is accessed.
+        /// </summary>
+        IList<IGroupDocs> Groups { get; }
+
+        SortField[] GroupSort { get; }
+
+        SortField[] WithinGroupSort { get; }
+
+        float MaxScore { get; }
+    }
 }