lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nightowl...@apache.org
Subject [53/58] [abbrv] lucenenet git commit: Grouping: Fixed up documentation comments and license headers
Date Thu, 10 Nov 2016 11:34:04 GMT
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/a0a61e24/src/Lucene.Net.Grouping/Term/TermAllGroupHeadsCollector.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Grouping/Term/TermAllGroupHeadsCollector.cs b/src/Lucene.Net.Grouping/Term/TermAllGroupHeadsCollector.cs
index 8b5776e..175dd0a 100644
--- a/src/Lucene.Net.Grouping/Term/TermAllGroupHeadsCollector.cs
+++ b/src/Lucene.Net.Grouping/Term/TermAllGroupHeadsCollector.cs
@@ -5,6 +5,23 @@ using System.Collections.Generic;
 
 namespace Lucene.Net.Search.Grouping.Terms
 {
+    /*
+	 * Licensed to the Apache Software Foundation (ASF) under one or more
+	 * contributor license agreements.  See the NOTICE file distributed with
+	 * this work for additional information regarding copyright ownership.
+	 * The ASF licenses this file to You under the Apache License, Version 2.0
+	 * (the "License"); you may not use this file except in compliance with
+	 * the License.  You may obtain a copy of the License at
+	 *
+	 *     http://www.apache.org/licenses/LICENSE-2.0
+	 *
+	 * Unless required by applicable law or agreed to in writing, software
+	 * distributed under the License is distributed on an "AS IS" BASIS,
+	 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+	 * See the License for the specific language governing permissions and
+	 * limitations under the License.
+	 */
+
     /// <summary>
     /// A base implementation of <see cref="AbstractAllGroupHeadsCollector{GH}"/> for
retrieving the most relevant groups when grouping
     /// on a string based group field. More specifically this all concrete implementations
of this base implementation
@@ -29,39 +46,48 @@ namespace Lucene.Net.Search.Grouping.Terms
         }
     }
 
+    /// <summary>
+    /// LUCENENET specific class used to mimic the synatax used to access
+    /// static members of <see cref="TermAllGroupHeadsCollector{GH}"/> without
+    /// specifying its generic closing type.
+    /// (TermAllGroupHeadsCollector.Create() rather than TermAllGroupHeadsCollector{GH}.Create()).
+    /// </summary>
     public class TermAllGroupHeadsCollector
     {
         private static readonly int DEFAULT_INITIAL_SIZE = 128;
 
-        // Disallow creation
+        /// <summary>
+        /// Disallow creation
+        /// </summary>
         private TermAllGroupHeadsCollector() { }
 
-        /**
-         * Creates an <code>AbstractAllGroupHeadsCollector</code> instance based
on the supplied arguments.
-         * This factory method decides with implementation is best suited.
-         *
-         * Delegates to {@link #create(String, org.apache.lucene.search.Sort, int)} with
an initialSize of 128.
-         *
-         * @param groupField      The field to group by
-         * @param sortWithinGroup The sort within each group
-         * @return an <code>AbstractAllGroupHeadsCollector</code> instance based
on the supplied arguments
-         */
+        /// <summary>
+        /// Creates an <see cref=AbstractAllGroupHeadsCollector""/> instance based
on the supplied arguments.
+        /// This factory method decides with implementation is best suited.
+        /// <para>
+        /// Delegates to <see cref="Create(string, Sort, int)"/> with an initialSize
of 128.
+        /// </para>
+        /// </summary>
+        /// <param name="groupField">The field to group by</param>
+        /// <param name="sortWithinGroup">The sort within each group</param>
+        /// <returns>an <see cref="AbstractAllGroupHeadsCollector"/> instance
based on the supplied arguments</returns>
         public static AbstractAllGroupHeadsCollector Create(string groupField, Sort sortWithinGroup)
         {
             return Create(groupField, sortWithinGroup, DEFAULT_INITIAL_SIZE);
         }
 
-        /**
-         * Creates an <code>AbstractAllGroupHeadsCollector</code> instance based
on the supplied arguments.
-         * This factory method decides with implementation is best suited.
-         *
-         * @param groupField      The field to group by
-         * @param sortWithinGroup The sort within each group
-         * @param initialSize The initial allocation size of the internal int set and group
list which should roughly match
-         *                    the total number of expected unique groups. Be aware that the
heap usage is
-         *                    4 bytes * initialSize.
-         * @return an <code>AbstractAllGroupHeadsCollector</code> instance based
on the supplied arguments
-         */
+        /// <summary>
+        /// Creates an <see cref="AbstractAllGroupHeadsCollector"/> instance based
on the supplied arguments.
+        /// This factory method decides with implementation is best suited.
+        /// </summary>
+        /// <param name="groupField">The field to group by</param>
+        /// <param name="sortWithinGroup">The sort within each group</param>
+        /// <param name="initialSize">
+        /// The initial allocation size of the internal int set and group list which should
roughly match
+        /// the total number of expected unique groups. Be aware that the heap usage is
+        /// 4 bytes * initialSize.
+        /// </param>
+        /// <returns>an <see cref="AbstractAllGroupHeadsCollector"/> instance
based on the supplied arguments</returns>
         public static AbstractAllGroupHeadsCollector Create(string groupField, Sort sortWithinGroup,
int initialSize)
         {
             bool sortAllScore = true;
@@ -97,7 +123,9 @@ namespace Lucene.Net.Search.Grouping.Terms
             }
         }
 
-        // Returns when a sort field needs the general impl.
+        /// <summary>
+        /// Returns when a sort field needs the general impl.
+        /// </summary>
         private static bool NeedGeneralImpl(SortField sortField)
         {
             SortField.Type_e sortType = sortField.Type;
@@ -106,7 +134,9 @@ namespace Lucene.Net.Search.Grouping.Terms
         }
     }
 
-    // A general impl that works for any group sort.
+    /// <summary>
+    /// A general impl that works for any group sort.
+    /// </summary>
     internal class GeneralAllGroupHeadsCollector : TermAllGroupHeadsCollector<GeneralAllGroupHeadsCollector.GroupHead>
     {
 
@@ -195,6 +225,8 @@ namespace Lucene.Net.Search.Grouping.Terms
         internal class GroupHead : AbstractAllGroupHeadsCollector_GroupHead /*AbstractAllGroupHeadsCollector.GroupHead<BytesRef>*/
         {
             private readonly GeneralAllGroupHeadsCollector outerInstance;
+            // LUCENENET: Moved groupValue here from the base class, AbstractAllGroupHeadsCollector_GroupHead
so it doesn't
+            // need to reference the generic closing type BytesRef.
             public readonly BytesRef groupValue;
 
             internal readonly FieldComparator[] comparators;
@@ -234,10 +266,11 @@ namespace Lucene.Net.Search.Grouping.Terms
     }
 
 
-    // AbstractAllGroupHeadsCollector optimized for ord fields and scores.
+    /// <summary>
+    /// AbstractAllGroupHeadsCollector optimized for ord fields and scores.
+    /// </summary>
     internal class OrdScoreAllGroupHeadsCollector : TermAllGroupHeadsCollector<OrdScoreAllGroupHeadsCollector.GroupHead>
     {
-        //private readonly TermAllGroupHeadsCollector<GH> outerInstance;
         private readonly SentinelIntSet ordSet;
         private readonly IList<GroupHead> collectedGroups;
         private readonly SortField[] fields;
@@ -246,10 +279,9 @@ namespace Lucene.Net.Search.Grouping.Terms
         private Scorer scorer;
         private GroupHead[] segmentGroupHeads;
 
-        internal OrdScoreAllGroupHeadsCollector(/*TermAllGroupHeadsCollector<GH> outerInstance,*/
string groupField, Sort sortWithinGroup, int initialSize)
+        internal OrdScoreAllGroupHeadsCollector(string groupField, Sort sortWithinGroup,
int initialSize)
             : base(groupField, sortWithinGroup.GetSort().Length)
         {
-            //this.outerInstance = outerInstance;
             ordSet = new SentinelIntSet(initialSize, -2);
             collectedGroups = new List<GroupHead>(initialSize);
 
@@ -368,6 +400,8 @@ namespace Lucene.Net.Search.Grouping.Terms
         internal class GroupHead : AbstractAllGroupHeadsCollector_GroupHead /*AbstractAllGroupHeadsCollector.GroupHead<BytesRef>*/
         {
             private readonly OrdScoreAllGroupHeadsCollector outerInstance;
+            // LUCENENET: Moved groupValue here from the base class, AbstractAllGroupHeadsCollector_GroupHead
so it doesn't
+            // need to reference the generic closing type BytesRef.
             public readonly BytesRef groupValue;
 
             internal BytesRef[] sortValues;
@@ -465,10 +499,11 @@ namespace Lucene.Net.Search.Grouping.Terms
     }
 
 
-    // AbstractAllGroupHeadsCollector optimized for ord fields.
+    /// <summary>
+    /// AbstractAllGroupHeadsCollector optimized for ord fields.
+    /// </summary>
     internal class OrdAllGroupHeadsCollector : TermAllGroupHeadsCollector<OrdAllGroupHeadsCollector.GroupHead>
     {
-        //private readonly TermAllGroupHeadsCollector<GH> outerInstance;
         private readonly SentinelIntSet ordSet;
         private readonly IList<GroupHead> collectedGroups;
         private readonly SortField[] fields;
@@ -476,10 +511,9 @@ namespace Lucene.Net.Search.Grouping.Terms
         private SortedDocValues[] sortsIndex;
         private GroupHead[] segmentGroupHeads;
 
-        internal OrdAllGroupHeadsCollector(/*TermAllGroupHeadsCollector<GH> outerInstance,*/
string groupField, Sort sortWithinGroup, int initialSize)
+        internal OrdAllGroupHeadsCollector(string groupField, Sort sortWithinGroup, int initialSize)
                     : base(groupField, sortWithinGroup.GetSort().Length)
         {
-            //this.outerInstance = outerInstance;
             ordSet = new SentinelIntSet(initialSize, -2);
             collectedGroups = new List<GroupHead>(initialSize);
 
@@ -587,6 +621,8 @@ namespace Lucene.Net.Search.Grouping.Terms
         internal class GroupHead : AbstractAllGroupHeadsCollector_GroupHead /* AbstractAllGroupHeadsCollector.GroupHead<BytesRef>*/
         {
             private readonly OrdAllGroupHeadsCollector outerInstance;
+            // LUCENENET: Moved groupValue here from the base class, AbstractAllGroupHeadsCollector_GroupHead
so it doesn't
+            // need to reference the generic closing type BytesRef.
             public readonly BytesRef groupValue;
             internal BytesRef[] sortValues;
             internal int[] sortOrds;
@@ -653,10 +689,11 @@ namespace Lucene.Net.Search.Grouping.Terms
     }
 
 
-    // AbstractAllGroupHeadsCollector optimized for scores.
+    /// <summary>
+    /// AbstractAllGroupHeadsCollector optimized for scores.
+    /// </summary>
     internal class ScoreAllGroupHeadsCollector : TermAllGroupHeadsCollector<ScoreAllGroupHeadsCollector.GroupHead>
     {
-        //private readonly TermAllGroupHeadsCollector<GH> outerInstance;
         private readonly SentinelIntSet ordSet;
         private readonly IList<GroupHead> collectedGroups;
         private readonly SortField[] fields;
@@ -664,10 +701,9 @@ namespace Lucene.Net.Search.Grouping.Terms
         private Scorer scorer;
         private GroupHead[] segmentGroupHeads;
 
-        internal ScoreAllGroupHeadsCollector(/*TermAllGroupHeadsCollector<GH> outerInstance,*/
string groupField, Sort sortWithinGroup, int initialSize)
+        internal ScoreAllGroupHeadsCollector(string groupField, Sort sortWithinGroup, int
initialSize)
                     : base(groupField, sortWithinGroup.GetSort().Length)
         {
-            //this.outerInstance = outerInstance;
             ordSet = new SentinelIntSet(initialSize, -2);
             collectedGroups = new List<GroupHead>(initialSize);
 
@@ -755,7 +791,7 @@ namespace Lucene.Net.Search.Grouping.Terms
         internal class GroupHead : AbstractAllGroupHeadsCollector_GroupHead
         {
             private readonly ScoreAllGroupHeadsCollector outerInstance;
-            // LUCENENET: Moved this here from the base class, AbstractAllGroupHeadsCollector_GroupHead
so it doesn't
+            // LUCENENET: Moved groupValue here from the base class, AbstractAllGroupHeadsCollector_GroupHead
so it doesn't
             // need to reference the generic closing type BytesRef.
             public readonly BytesRef groupValue;
             internal float[] scores;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/a0a61e24/src/Lucene.Net.Grouping/Term/TermAllGroupsCollector.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Grouping/Term/TermAllGroupsCollector.cs b/src/Lucene.Net.Grouping/Term/TermAllGroupsCollector.cs
index 953bb82..17b0438 100644
--- a/src/Lucene.Net.Grouping/Term/TermAllGroupsCollector.cs
+++ b/src/Lucene.Net.Grouping/Term/TermAllGroupsCollector.cs
@@ -5,6 +5,23 @@ using System.Collections.Generic;
 
 namespace Lucene.Net.Search.Grouping.Terms
 {
+    /*
+	 * Licensed to the Apache Software Foundation (ASF) under one or more
+	 * contributor license agreements.  See the NOTICE file distributed with
+	 * this work for additional information regarding copyright ownership.
+	 * The ASF licenses this file to You under the Apache License, Version 2.0
+	 * (the "License"); you may not use this file except in compliance with
+	 * the License.  You may obtain a copy of the License at
+	 *
+	 *     http://www.apache.org/licenses/LICENSE-2.0
+	 *
+	 * Unless required by applicable law or agreed to in writing, software
+	 * distributed under the License is distributed on an "AS IS" BASIS,
+	 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+	 * See the License for the specific language governing permissions and
+	 * limitations under the License.
+	 */
+
     /// <summary>
     /// A collector that collects all groups that match the
     /// query. Only the group value is collected, and the order

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/a0a61e24/src/Lucene.Net.Grouping/Term/TermDistinctValuesCollector.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Grouping/Term/TermDistinctValuesCollector.cs b/src/Lucene.Net.Grouping/Term/TermDistinctValuesCollector.cs
index 91bc674..a41cba3 100644
--- a/src/Lucene.Net.Grouping/Term/TermDistinctValuesCollector.cs
+++ b/src/Lucene.Net.Grouping/Term/TermDistinctValuesCollector.cs
@@ -7,6 +7,23 @@ using System.Linq;
 
 namespace Lucene.Net.Search.Grouping.Terms
 {
+    /*
+	 * Licensed to the Apache Software Foundation (ASF) under one or more
+	 * contributor license agreements.  See the NOTICE file distributed with
+	 * this work for additional information regarding copyright ownership.
+	 * The ASF licenses this file to You under the Apache License, Version 2.0
+	 * (the "License"); you may not use this file except in compliance with
+	 * the License.  You may obtain a copy of the License at
+	 *
+	 *     http://www.apache.org/licenses/LICENSE-2.0
+	 *
+	 * Unless required by applicable law or agreed to in writing, software
+	 * distributed under the License is distributed on an "AS IS" BASIS,
+	 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+	 * See the License for the specific language governing permissions and
+	 * limitations under the License.
+	 */
+
     /// <summary>
     /// A term based implementation of <see cref="AbstractDistinctValuesCollector{TermDistinctValuesCollector.GroupCount}"/>
that relies
     /// on <see cref="SortedDocValues"/> to count the distinct values per group.
@@ -24,13 +41,12 @@ namespace Lucene.Net.Search.Grouping.Terms
         private SortedDocValues groupFieldTermIndex;
         private SortedDocValues countFieldTermIndex;
 
-        /**
-         * Constructs {@link TermDistinctValuesCollector} instance.
-         *
-         * @param groupField The field to group by
-         * @param countField The field to count distinct values for
-         * @param groups The top N groups, collected during the first phase search
-         */
+        /// <summary>
+        /// Constructs <see cref="TermDistinctValuesCollector"/> instance.
+        /// </summary>
+        /// <param name="groupField">The field to group by</param>
+        /// <param name="countField">The field to count distinct values for</param>
+        /// <param name="groups">The top N groups, collected during the first phase
search</param>
         public TermDistinctValuesCollector(string groupField, string countField, IEnumerable<ISearchGroup<BytesRef>>
groups)
         {
             this.groupField = groupField;
@@ -126,9 +142,11 @@ namespace Lucene.Net.Search.Grouping.Terms
             }
         }
 
-        /** Holds distinct values for a single group.
-         *
-         * @lucene.experimental */
+        /// <summary>
+        /// Holds distinct values for a single group.
+        /// 
+        /// @lucene.experimental
+        /// </summary>
         public class GroupCount : AbstractDistinctValuesCollector.GroupCount<BytesRef>
         {
             internal int[] ords;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/a0a61e24/src/Lucene.Net.Grouping/Term/TermFirstPassGroupingCollector.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Grouping/Term/TermFirstPassGroupingCollector.cs b/src/Lucene.Net.Grouping/Term/TermFirstPassGroupingCollector.cs
index 9f61ae7..20775f9 100644
--- a/src/Lucene.Net.Grouping/Term/TermFirstPassGroupingCollector.cs
+++ b/src/Lucene.Net.Grouping/Term/TermFirstPassGroupingCollector.cs
@@ -3,6 +3,23 @@ using Lucene.Net.Util;
 
 namespace Lucene.Net.Search.Grouping.Terms
 {
+    /*
+	 * Licensed to the Apache Software Foundation (ASF) under one or more
+	 * contributor license agreements.  See the NOTICE file distributed with
+	 * this work for additional information regarding copyright ownership.
+	 * The ASF licenses this file to You under the Apache License, Version 2.0
+	 * (the "License"); you may not use this file except in compliance with
+	 * the License.  You may obtain a copy of the License at
+	 *
+	 *     http://www.apache.org/licenses/LICENSE-2.0
+	 *
+	 * Unless required by applicable law or agreed to in writing, software
+	 * distributed under the License is distributed on an "AS IS" BASIS,
+	 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+	 * See the License for the specific language governing permissions and
+	 * limitations under the License.
+	 */
+
     /// <summary>
     /// Concrete implementation of <see cref="AbstractFirstPassGroupingCollector{BytesRef}"/>
that groups based on
     /// field values and more specifically uses <see cref="SortedDocValues"/>

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/a0a61e24/src/Lucene.Net.Grouping/Term/TermGroupFacetCollector.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Grouping/Term/TermGroupFacetCollector.cs b/src/Lucene.Net.Grouping/Term/TermGroupFacetCollector.cs
index e694ef2..690e31e 100644
--- a/src/Lucene.Net.Grouping/Term/TermGroupFacetCollector.cs
+++ b/src/Lucene.Net.Grouping/Term/TermGroupFacetCollector.cs
@@ -5,6 +5,23 @@ using System.Diagnostics;
 
 namespace Lucene.Net.Search.Grouping.Terms
 {
+    /*
+	 * Licensed to the Apache Software Foundation (ASF) under one or more
+	 * contributor license agreements.  See the NOTICE file distributed with
+	 * this work for additional information regarding copyright ownership.
+	 * The ASF licenses this file to You under the Apache License, Version 2.0
+	 * (the "License"); you may not use this file except in compliance with
+	 * the License.  You may obtain a copy of the License at
+	 *
+	 *     http://www.apache.org/licenses/LICENSE-2.0
+	 *
+	 * Unless required by applicable law or agreed to in writing, software
+	 * distributed under the License is distributed on an "AS IS" BASIS,
+	 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+	 * See the License for the specific language governing permissions and
+	 * limitations under the License.
+	 */
+
     /// <summary>
     /// An implementation of <see cref="AbstractGroupFacetCollector"/> that computes
grouped facets based on the indexed terms
     /// from the <see cref="FieldCache"/>.
@@ -18,19 +35,20 @@ namespace Lucene.Net.Search.Grouping.Terms
 
         internal SortedDocValues groupFieldTermsIndex;
 
-        /**
-         * Factory method for creating the right implementation based on the fact whether
the facet field contains
-         * multiple tokens per documents.
-         *
-         * @param groupField The group field
-         * @param facetField The facet field
-         * @param facetFieldMultivalued Whether the facet field has multiple tokens per document
-         * @param facetPrefix The facet prefix a facet entry should start with to be included.
-         * @param initialSize The initial allocation size of the internal int set and group
facet list which should roughly
-         *                    match the total number of expected unique groups. Be aware
that the heap usage is
-         *                    4 bytes * initialSize.
-         * @return <code>TermGroupFacetCollector</code> implementation
-         */
+        /// <summary>
+        /// Factory method for creating the right implementation based on the fact whether
the facet field contains
+        /// multiple tokens per documents.
+        /// </summary>
+        /// <param name="groupField">The group field</param>
+        /// <param name="facetField">The facet field</param>
+        /// <param name="facetFieldMultivalued">Whether the facet field has multiple
tokens per document</param>
+        /// <param name="facetPrefix">The facet prefix a facet entry should start with
to be included.</param>
+        /// <param name="initialSize">
+        /// The initial allocation size of the internal int set and group facet list which
should roughly
+        /// match the total number of expected unique groups. Be aware that the heap usage
is
+        /// 4 bytes * initialSize.
+        /// </param>
+        /// <returns><see cref="TermGroupFacetCollector"/> implementation</returns>
         public static TermGroupFacetCollector CreateTermGroupFacetCollector(string groupField,
                                                                             string facetField,
                                                                             bool facetFieldMultivalued,
@@ -54,7 +72,9 @@ namespace Lucene.Net.Search.Grouping.Terms
             segmentGroupedFacetHits = new SentinelIntSet(initialSize, int.MinValue);
         }
 
-        // Implementation for single valued facet fields.
+        /// <summary>
+        /// Implementation for single valued facet fields.
+        /// </summary>
         internal class SV : TermGroupFacetCollector
         {
 
@@ -198,7 +218,9 @@ namespace Lucene.Net.Search.Grouping.Terms
             }
         }
 
-        // Implementation for multi valued facet fields.
+        /// <summary>
+        /// Implementation for multi valued facet fields.
+        /// </summary>
         internal class MV : TermGroupFacetCollector
         {
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/a0a61e24/src/Lucene.Net.Grouping/Term/TermSecondPassGroupingCollector.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Grouping/Term/TermSecondPassGroupingCollector.cs b/src/Lucene.Net.Grouping/Term/TermSecondPassGroupingCollector.cs
index c9de6c1..22b0365 100644
--- a/src/Lucene.Net.Grouping/Term/TermSecondPassGroupingCollector.cs
+++ b/src/Lucene.Net.Grouping/Term/TermSecondPassGroupingCollector.cs
@@ -4,6 +4,23 @@ using System.Collections.Generic;
 
 namespace Lucene.Net.Search.Grouping.Terms
 {
+    /*
+	 * Licensed to the Apache Software Foundation (ASF) under one or more
+	 * contributor license agreements.  See the NOTICE file distributed with
+	 * this work for additional information regarding copyright ownership.
+	 * The ASF licenses this file to You under the Apache License, Version 2.0
+	 * (the "License"); you may not use this file except in compliance with
+	 * the License.  You may obtain a copy of the License at
+	 *
+	 *     http://www.apache.org/licenses/LICENSE-2.0
+	 *
+	 * Unless required by applicable law or agreed to in writing, software
+	 * distributed under the License is distributed on an "AS IS" BASIS,
+	 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+	 * See the License for the specific language governing permissions and
+	 * limitations under the License.
+	 */
+
     /// <summary>
     /// Concrete implementation of <see cref="AbstractSecondPassGroupingCollector{BytesRef}"/>
that groups based on
     /// field values and more specifically uses <see cref="SortedDocValues"/>

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/a0a61e24/src/Lucene.Net.Grouping/TopGroups.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Grouping/TopGroups.cs b/src/Lucene.Net.Grouping/TopGroups.cs
index d66439d..d8a2165 100644
--- a/src/Lucene.Net.Grouping/TopGroups.cs
+++ b/src/Lucene.Net.Grouping/TopGroups.cs
@@ -260,7 +260,7 @@ namespace Lucene.Net.Search.Grouping
 
     /// <summary>
     /// LUCENENET specific interface used to provide covariance
-    /// with the TGroupValue type
+    /// with the TGroupValue type to simulate Java's wildcard generics.
     /// </summary>
     /// <typeparam name="TGroupValue"></typeparam>
     public interface ITopGroups<out TGroupValue>

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/a0a61e24/src/Lucene.Net.Tests.Grouping/AbstractGroupingTestCase.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Grouping/AbstractGroupingTestCase.cs b/src/Lucene.Net.Tests.Grouping/AbstractGroupingTestCase.cs
index 74a926a..d434a80 100644
--- a/src/Lucene.Net.Tests.Grouping/AbstractGroupingTestCase.cs
+++ b/src/Lucene.Net.Tests.Grouping/AbstractGroupingTestCase.cs
@@ -3,6 +3,23 @@ using System;
 
 namespace Lucene.Net.Search.Grouping
 {
+    /*
+	 * Licensed to the Apache Software Foundation (ASF) under one or more
+	 * contributor license agreements.  See the NOTICE file distributed with
+	 * this work for additional information regarding copyright ownership.
+	 * The ASF licenses this file to You under the Apache License, Version 2.0
+	 * (the "License"); you may not use this file except in compliance with
+	 * the License.  You may obtain a copy of the License at
+	 *
+	 *     http://www.apache.org/licenses/LICENSE-2.0
+	 *
+	 * Unless required by applicable law or agreed to in writing, software
+	 * distributed under the License is distributed on an "AS IS" BASIS,
+	 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+	 * See the License for the specific language governing permissions and
+	 * limitations under the License.
+	 */
+
     /// <summary>
     /// Base class for grouping related tests.
     /// </summary>

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/a0a61e24/src/Lucene.Net.Tests.Grouping/AllGroupHeadsCollectorTest.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Grouping/AllGroupHeadsCollectorTest.cs b/src/Lucene.Net.Tests.Grouping/AllGroupHeadsCollectorTest.cs
index c7cac67..8d6ca76 100644
--- a/src/Lucene.Net.Tests.Grouping/AllGroupHeadsCollectorTest.cs
+++ b/src/Lucene.Net.Tests.Grouping/AllGroupHeadsCollectorTest.cs
@@ -17,6 +17,23 @@ using System.Text;
 
 namespace Lucene.Net.Search.Grouping
 {
+    /*
+	 * Licensed to the Apache Software Foundation (ASF) under one or more
+	 * contributor license agreements.  See the NOTICE file distributed with
+	 * this work for additional information regarding copyright ownership.
+	 * The ASF licenses this file to You under the Apache License, Version 2.0
+	 * (the "License"); you may not use this file except in compliance with
+	 * the License.  You may obtain a copy of the License at
+	 *
+	 *     http://www.apache.org/licenses/LICENSE-2.0
+	 *
+	 * Unless required by applicable law or agreed to in writing, software
+	 * distributed under the License is distributed on an "AS IS" BASIS,
+	 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+	 * See the License for the specific language governing permissions and
+	 * limitations under the License.
+	 */
+
     public class AllGroupHeadsCollectorTest : LuceneTestCase
     {
         private static readonly FieldInfo.DocValuesType_e[] vts = new FieldInfo.DocValuesType_e[]{

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/a0a61e24/src/Lucene.Net.Tests.Grouping/AllGroupsCollectorTest.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Grouping/AllGroupsCollectorTest.cs b/src/Lucene.Net.Tests.Grouping/AllGroupsCollectorTest.cs
index 2d42c43..28aa28d 100644
--- a/src/Lucene.Net.Tests.Grouping/AllGroupsCollectorTest.cs
+++ b/src/Lucene.Net.Tests.Grouping/AllGroupsCollectorTest.cs
@@ -13,6 +13,23 @@ using System.Collections;
 
 namespace Lucene.Net.Search.Grouping
 {
+    /*
+	 * Licensed to the Apache Software Foundation (ASF) under one or more
+	 * contributor license agreements.  See the NOTICE file distributed with
+	 * this work for additional information regarding copyright ownership.
+	 * The ASF licenses this file to You under the Apache License, Version 2.0
+	 * (the "License"); you may not use this file except in compliance with
+	 * the License.  You may obtain a copy of the License at
+	 *
+	 *     http://www.apache.org/licenses/LICENSE-2.0
+	 *
+	 * Unless required by applicable law or agreed to in writing, software
+	 * distributed under the License is distributed on an "AS IS" BASIS,
+	 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+	 * See the License for the specific language governing permissions and
+	 * limitations under the License.
+	 */
+
     public class AllGroupsCollectorTest : LuceneTestCase
     {
         [Test]

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/a0a61e24/src/Lucene.Net.Tests.Grouping/DistinctValuesCollectorTest.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Grouping/DistinctValuesCollectorTest.cs b/src/Lucene.Net.Tests.Grouping/DistinctValuesCollectorTest.cs
index 711f339..5ef9589 100644
--- a/src/Lucene.Net.Tests.Grouping/DistinctValuesCollectorTest.cs
+++ b/src/Lucene.Net.Tests.Grouping/DistinctValuesCollectorTest.cs
@@ -17,6 +17,23 @@ using System.Linq;
 
 namespace Lucene.Net.Search.Grouping
 {
+    /*
+	 * Licensed to the Apache Software Foundation (ASF) under one or more
+	 * contributor license agreements.  See the NOTICE file distributed with
+	 * this work for additional information regarding copyright ownership.
+	 * The ASF licenses this file to You under the Apache License, Version 2.0
+	 * (the "License"); you may not use this file except in compliance with
+	 * the License.  You may obtain a copy of the License at
+	 *
+	 *     http://www.apache.org/licenses/LICENSE-2.0
+	 *
+	 * Unless required by applicable law or agreed to in writing, software
+	 * distributed under the License is distributed on an "AS IS" BASIS,
+	 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+	 * See the License for the specific language governing permissions and
+	 * limitations under the License.
+	 */
+
     public class DistinctValuesCollectorTest : AbstractGroupingTestCase
     {
         private readonly static NullComparator nullComparator = new NullComparator();

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/a0a61e24/src/Lucene.Net.Tests.Grouping/GroupFacetCollectorTest.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Grouping/GroupFacetCollectorTest.cs b/src/Lucene.Net.Tests.Grouping/GroupFacetCollectorTest.cs
index e50c91b..c4fc0dc 100644
--- a/src/Lucene.Net.Tests.Grouping/GroupFacetCollectorTest.cs
+++ b/src/Lucene.Net.Tests.Grouping/GroupFacetCollectorTest.cs
@@ -14,6 +14,23 @@ using System.Linq;
 
 namespace Lucene.Net.Search.Grouping
 {
+    /*
+	 * Licensed to the Apache Software Foundation (ASF) under one or more
+	 * contributor license agreements.  See the NOTICE file distributed with
+	 * this work for additional information regarding copyright ownership.
+	 * The ASF licenses this file to You under the Apache License, Version 2.0
+	 * (the "License"); you may not use this file except in compliance with
+	 * the License.  You may obtain a copy of the License at
+	 *
+	 *     http://www.apache.org/licenses/LICENSE-2.0
+	 *
+	 * Unless required by applicable law or agreed to in writing, software
+	 * distributed under the License is distributed on an "AS IS" BASIS,
+	 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+	 * See the License for the specific language governing permissions and
+	 * limitations under the License.
+	 */
+
     public class GroupFacetCollectorTest : AbstractGroupingTestCase
     {
         [Test]

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/a0a61e24/src/Lucene.Net.Tests.Grouping/GroupingSearchTest.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Grouping/GroupingSearchTest.cs b/src/Lucene.Net.Tests.Grouping/GroupingSearchTest.cs
index 49b56e6..bb8dca2 100644
--- a/src/Lucene.Net.Tests.Grouping/GroupingSearchTest.cs
+++ b/src/Lucene.Net.Tests.Grouping/GroupingSearchTest.cs
@@ -13,6 +13,23 @@ using System.Collections.Generic;
 
 namespace Lucene.Net.Search.Grouping
 {
+    /*
+	 * Licensed to the Apache Software Foundation (ASF) under one or more
+	 * contributor license agreements.  See the NOTICE file distributed with
+	 * this work for additional information regarding copyright ownership.
+	 * The ASF licenses this file to You under the Apache License, Version 2.0
+	 * (the "License"); you may not use this file except in compliance with
+	 * the License.  You may obtain a copy of the License at
+	 *
+	 *     http://www.apache.org/licenses/LICENSE-2.0
+	 *
+	 * Unless required by applicable law or agreed to in writing, software
+	 * distributed under the License is distributed on an "AS IS" BASIS,
+	 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+	 * See the License for the specific language governing permissions and
+	 * limitations under the License.
+	 */
+
     public class GroupingSearchTest : LuceneTestCase
     {
         // Tests some very basic usages...


Mime
View raw message