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 330c25abcfb128cab85edab9a2bff8caaceae3c0 Author: Shad Storhaug <[email protected]> AuthorDate: Fri Aug 28 12:48:01 2020 +0700 Changed all Terms subclasses to use GetEnumerator() instead of GetIterator() (see #279, #212) --- .../BlockTerms/BlockTermsReader.cs | 2 +- .../Bloom/BloomFilteringPostingsFormat.cs | 32 ++++++++++++++-------- .../Memory/DirectPostingsFormat.cs | 23 +++++++--------- src/Lucene.Net.Codecs/Memory/FSTOrdTermsReader.cs | 4 +-- src/Lucene.Net.Codecs/Memory/FSTTermsReader.cs | 4 +-- .../Memory/MemoryPostingsFormat.cs | 2 +- .../SimpleText/SimpleTextFieldsReader.cs | 6 ++-- .../SimpleText/SimpleTextTermVectorsReader.cs | 2 +- .../MemoryIndex.MemoryIndexReader.cs | 2 +- .../Index/Sorter/SortingAtomicReader.cs | 9 ++++-- src/Lucene.Net.Sandbox/Queries/SlowFuzzyQuery.cs | 2 +- .../Queries/SlowFuzzyTermsEnum.cs | 2 +- .../Codecs/RAMOnly/RAMOnlyPostingsFormat.cs | 2 +- .../Index/AssertingAtomicReader.cs | 27 +++++++++++------- .../Index/TestFilterAtomicReader.cs | 16 +++++++++-- src/Lucene.Net/Codecs/BlockTreeTermsReader.cs | 2 +- .../Compressing/CompressingTermVectorsReader.cs | 16 +++++++---- src/Lucene.Net/Codecs/Lucene3x/Lucene3xFields.cs | 2 +- .../Codecs/Lucene3x/Lucene3xTermVectorsReader.cs | 26 ++++++++++++------ .../Codecs/Lucene40/Lucene40TermVectorsReader.cs | 26 ++++++++++++------ src/Lucene.Net/Index/FilterAtomicReader.cs | 7 ++--- src/Lucene.Net/Index/MultiTerms.cs | 4 +-- src/Lucene.Net/Index/Terms.cs | 17 ++++++------ src/Lucene.Net/Search/DocTermOrdsRewriteMethod.cs | 12 ++++---- src/Lucene.Net/Search/FieldCacheRewriteMethod.cs | 6 ++-- 25 files changed, 150 insertions(+), 103 deletions(-) diff --git a/src/Lucene.Net.Codecs/BlockTerms/BlockTermsReader.cs b/src/Lucene.Net.Codecs/BlockTerms/BlockTermsReader.cs index abffd20..6da7d50 100644 --- a/src/Lucene.Net.Codecs/BlockTerms/BlockTermsReader.cs +++ b/src/Lucene.Net.Codecs/BlockTerms/BlockTermsReader.cs @@ -272,7 +272,7 @@ namespace Lucene.Net.Codecs.BlockTerms public override IComparer<BytesRef> Comparer => BytesRef.UTF8SortedAsUnicodeComparer; - public override TermsEnum GetIterator(TermsEnum reuse) + public override TermsEnum GetEnumerator() { return new SegmentTermsEnum(this); } diff --git a/src/Lucene.Net.Codecs/Bloom/BloomFilteringPostingsFormat.cs b/src/Lucene.Net.Codecs/Bloom/BloomFilteringPostingsFormat.cs index 6b04cf9..ad236a5 100644 --- a/src/Lucene.Net.Codecs/Bloom/BloomFilteringPostingsFormat.cs +++ b/src/Lucene.Net.Codecs/Bloom/BloomFilteringPostingsFormat.cs @@ -227,23 +227,33 @@ namespace Lucene.Net.Codecs.Bloom return _delegateTerms.Intersect(compiled, startTerm); } - public override TermsEnum GetIterator(TermsEnum reuse) + public override TermsEnum GetEnumerator() { - if (!(reuse is BloomFilteredTermsEnum)) - return new BloomFilteredTermsEnum(_delegateTerms, reuse, _filter); + return new BloomFilteredTermsEnum(_delegateTerms, reuseDelegate: null, _filter); + } - // recycle the existing BloomFilteredTermsEnum by asking the delegate - // to recycle its contained TermsEnum - var bfte = (BloomFilteredTermsEnum) reuse; + public override TermsEnum GetEnumerator(TermsEnum reuse) + { +#pragma warning disable IDE0038 // Use pattern matching + if (!(reuse is null) && reuse is BloomFilteredTermsEnum) +#pragma warning restore IDE0038 // Use pattern matching + { + BloomFilteredTermsEnum bfte = (BloomFilteredTermsEnum)reuse; + if (bfte.filter == _filter) + { + // recycle the existing BloomFilteredTermsEnum by asking the delegate + // to recycle its contained TermsEnum + bfte.Reset(_delegateTerms, bfte.delegateTermsEnum); + return bfte; + } + } - // We have been handed something we cannot reuse (either null, wrong + // We have been handed something we cannot reuse (either wrong // class or wrong filter) so allocate a new object - if (bfte.filter != _filter) return new BloomFilteredTermsEnum(_delegateTerms, reuse, _filter); - bfte.Reset(_delegateTerms, bfte.delegateTermsEnum); - return bfte; - + return new BloomFilteredTermsEnum(_delegateTerms, reuse, _filter); } + public override IComparer<BytesRef> Comparer => _delegateTerms.Comparer; public override long Count => _delegateTerms.Count; diff --git a/src/Lucene.Net.Codecs/Memory/DirectPostingsFormat.cs b/src/Lucene.Net.Codecs/Memory/DirectPostingsFormat.cs index d929c19..a0f73f2 100644 --- a/src/Lucene.Net.Codecs/Memory/DirectPostingsFormat.cs +++ b/src/Lucene.Net.Codecs/Memory/DirectPostingsFormat.cs @@ -791,21 +791,18 @@ namespace Lucene.Net.Codecs.Memory } } - public override TermsEnum GetIterator(TermsEnum reuse) + public override TermsEnum GetEnumerator() { - DirectTermsEnum termsEnum; - if (reuse != null && reuse is DirectTermsEnum) - { - termsEnum = (DirectTermsEnum) reuse; - if (!termsEnum.CanReuse(terms)) - { - termsEnum = new DirectTermsEnum(this); - } - } - else - { + var termsEnum = new DirectTermsEnum(this); + termsEnum.Reset(); + return termsEnum; + } + + public override TermsEnum GetEnumerator(TermsEnum reuse) + { + if (!(reuse is DirectTermsEnum termsEnum) || !termsEnum.CanReuse(terms)) termsEnum = new DirectTermsEnum(this); - } + termsEnum.Reset(); return termsEnum; } diff --git a/src/Lucene.Net.Codecs/Memory/FSTOrdTermsReader.cs b/src/Lucene.Net.Codecs/Memory/FSTOrdTermsReader.cs index 824a42f..7dbbe8c 100644 --- a/src/Lucene.Net.Codecs/Memory/FSTOrdTermsReader.cs +++ b/src/Lucene.Net.Codecs/Memory/FSTOrdTermsReader.cs @@ -259,7 +259,7 @@ namespace Lucene.Net.Codecs.Memory public override int DocCount => docCount; - public override TermsEnum GetIterator(TermsEnum reuse) + public override TermsEnum GetEnumerator() { return new SegmentTermsEnum(this); } @@ -563,7 +563,7 @@ namespace Lucene.Net.Codecs.Memory /// <summary>True when current term's metadata is decoded.</summary> private bool decoded; - /// <summary>True when there is pending term when calling <see cref="Next()"/>.</summary> + /// <summary>True when there is pending term when calling <see cref="MoveNext()"/>.</summary> private bool pending; /// <summary> diff --git a/src/Lucene.Net.Codecs/Memory/FSTTermsReader.cs b/src/Lucene.Net.Codecs/Memory/FSTTermsReader.cs index cea9d98..c88704a 100644 --- a/src/Lucene.Net.Codecs/Memory/FSTTermsReader.cs +++ b/src/Lucene.Net.Codecs/Memory/FSTTermsReader.cs @@ -231,7 +231,7 @@ namespace Lucene.Net.Codecs.Memory public override int DocCount => docCount; - public override TermsEnum GetIterator(TermsEnum reuse) + public override TermsEnum GetEnumerator() { return new SegmentTermsEnum(this); } @@ -436,7 +436,7 @@ namespace Lucene.Net.Codecs.Memory /// <summary>True when current term's metadata is decoded.</summary> private bool decoded; - /// <summary>True when there is pending term when calling <see cref="Next()"/>.</summary> + /// <summary>True when there is pending term when calling <see cref="MoveNext()"/>.</summary> private bool pending; /// <summary> diff --git a/src/Lucene.Net.Codecs/Memory/MemoryPostingsFormat.cs b/src/Lucene.Net.Codecs/Memory/MemoryPostingsFormat.cs index c567ba2..ac6b877 100644 --- a/src/Lucene.Net.Codecs/Memory/MemoryPostingsFormat.cs +++ b/src/Lucene.Net.Codecs/Memory/MemoryPostingsFormat.cs @@ -941,7 +941,7 @@ namespace Lucene.Net.Codecs.Memory public override long Count => termCount; - public override TermsEnum GetIterator(TermsEnum reuse) + public override TermsEnum GetEnumerator() { return new FSTTermsEnum(field, fst); } diff --git a/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldsReader.cs b/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldsReader.cs index c197749..d5f6ec9 100644 --- a/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldsReader.cs +++ b/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldsReader.cs @@ -652,10 +652,10 @@ namespace Lucene.Net.Codecs.SimpleText return (_fst != null) ? _fst.GetSizeInBytes() : 0; } - public override TermsEnum GetIterator(TermsEnum reuse) + public override TermsEnum GetEnumerator() { - return (_fst != null) - ? new SimpleTextTermsEnum(_outerInstance, _fst, _fieldInfo.IndexOptions) + return (_fst != null) + ? new SimpleTextTermsEnum(_outerInstance, _fst, _fieldInfo.IndexOptions) : TermsEnum.EMPTY; } diff --git a/src/Lucene.Net.Codecs/SimpleText/SimpleTextTermVectorsReader.cs b/src/Lucene.Net.Codecs/SimpleText/SimpleTextTermVectorsReader.cs index e4684cc..099439b 100644 --- a/src/Lucene.Net.Codecs/SimpleText/SimpleTextTermVectorsReader.cs +++ b/src/Lucene.Net.Codecs/SimpleText/SimpleTextTermVectorsReader.cs @@ -314,7 +314,7 @@ namespace Lucene.Net.Codecs.SimpleText terms = new JCG.SortedDictionary<BytesRef, SimpleTVPostings>(); } - public override TermsEnum GetIterator(TermsEnum reuse) + public override TermsEnum GetEnumerator() { // TODO: reuse return new SimpleTVTermsEnum(terms); diff --git a/src/Lucene.Net.Memory/MemoryIndex.MemoryIndexReader.cs b/src/Lucene.Net.Memory/MemoryIndex.MemoryIndexReader.cs index 942fd5a..0c34b04 100644 --- a/src/Lucene.Net.Memory/MemoryIndex.MemoryIndexReader.cs +++ b/src/Lucene.Net.Memory/MemoryIndex.MemoryIndexReader.cs @@ -176,7 +176,7 @@ namespace Lucene.Net.Index.Memory this.info = info; } - public override TermsEnum GetIterator(TermsEnum reuse) + public override TermsEnum GetEnumerator() { return new MemoryTermsEnum(outerInstance.outerInstance, info); } diff --git a/src/Lucene.Net.Misc/Index/Sorter/SortingAtomicReader.cs b/src/Lucene.Net.Misc/Index/Sorter/SortingAtomicReader.cs index 266f233..ab98827 100644 --- a/src/Lucene.Net.Misc/Index/Sorter/SortingAtomicReader.cs +++ b/src/Lucene.Net.Misc/Index/Sorter/SortingAtomicReader.cs @@ -82,9 +82,14 @@ namespace Lucene.Net.Index.Sorter this.indexOptions = indexOptions; } - public override TermsEnum GetIterator(TermsEnum reuse) + public override TermsEnum GetEnumerator() { - return new SortingTermsEnum(m_input.GetIterator(reuse), docMap, indexOptions); + return new SortingTermsEnum(m_input.GetEnumerator(), docMap, indexOptions); + } + + public override TermsEnum GetEnumerator(TermsEnum reuse) + { + return new SortingTermsEnum(m_input.GetEnumerator(reuse), docMap, indexOptions); } public override TermsEnum Intersect(CompiledAutomaton compiled, BytesRef startTerm) diff --git a/src/Lucene.Net.Sandbox/Queries/SlowFuzzyQuery.cs b/src/Lucene.Net.Sandbox/Queries/SlowFuzzyQuery.cs index dd00744..0e2e753 100644 --- a/src/Lucene.Net.Sandbox/Queries/SlowFuzzyQuery.cs +++ b/src/Lucene.Net.Sandbox/Queries/SlowFuzzyQuery.cs @@ -145,7 +145,7 @@ namespace Lucene.Net.Sandbox.Queries { if (!termLongEnough) { // can only match if it's exact - return new SingleTermsEnum(terms.GetIterator(null), m_term.Bytes); + return new SingleTermsEnum(terms.GetEnumerator(), m_term.Bytes); } return new SlowFuzzyTermsEnum(terms, atts, Term, minimumSimilarity, prefixLength); } diff --git a/src/Lucene.Net.Sandbox/Queries/SlowFuzzyTermsEnum.cs b/src/Lucene.Net.Sandbox/Queries/SlowFuzzyTermsEnum.cs index 6acb46f..12a16a0 100644 --- a/src/Lucene.Net.Sandbox/Queries/SlowFuzzyTermsEnum.cs +++ b/src/Lucene.Net.Sandbox/Queries/SlowFuzzyTermsEnum.cs @@ -87,7 +87,7 @@ namespace Lucene.Net.Sandbox.Queries /// </summary> /// <exception cref="IOException">If there is a low-level I/O error.</exception> public LinearFuzzyTermsEnum(SlowFuzzyTermsEnum outerInstance) - : base(outerInstance.m_terms.GetIterator(null)) + : base(outerInstance.m_terms.GetEnumerator()) { this.outerInstance = outerInstance; this.boostAtt = Attributes.AddAttribute<IBoostAttribute>(); diff --git a/src/Lucene.Net.TestFramework/Codecs/RAMOnly/RAMOnlyPostingsFormat.cs b/src/Lucene.Net.TestFramework/Codecs/RAMOnly/RAMOnlyPostingsFormat.cs index 9d86548..61e370e 100644 --- a/src/Lucene.Net.TestFramework/Codecs/RAMOnly/RAMOnlyPostingsFormat.cs +++ b/src/Lucene.Net.TestFramework/Codecs/RAMOnly/RAMOnlyPostingsFormat.cs @@ -164,7 +164,7 @@ namespace Lucene.Net.Codecs.RAMOnly public override int DocCount => docCount; - public override TermsEnum GetIterator(TermsEnum reuse) + public override TermsEnum GetEnumerator() { return new RAMTermsEnum(this); } diff --git a/src/Lucene.Net.TestFramework/Index/AssertingAtomicReader.cs b/src/Lucene.Net.TestFramework/Index/AssertingAtomicReader.cs index 51612e5..f71d824 100644 --- a/src/Lucene.Net.TestFramework/Index/AssertingAtomicReader.cs +++ b/src/Lucene.Net.TestFramework/Index/AssertingAtomicReader.cs @@ -64,15 +64,22 @@ namespace Lucene.Net.Index return new AssertingAtomicReader.AssertingTermsEnum(termsEnum); } - public override TermsEnum GetIterator(TermsEnum reuse) + public override TermsEnum GetEnumerator() + { + var termsEnum = base.GetEnumerator(); + if (Debugging.AssertsEnabled) Debugging.Assert(termsEnum != null); + return new AssertingAtomicReader.AssertingTermsEnum(termsEnum); + } + + public override TermsEnum GetEnumerator(TermsEnum reuse) { // TODO: should we give this thing a random to be super-evil, // and randomly *not* unwrap? - if (reuse is AssertingAtomicReader.AssertingTermsEnum) + if (!(reuse is null) && reuse is AssertingAtomicReader.AssertingTermsEnum reusable) { - reuse = ((AssertingAtomicReader.AssertingTermsEnum)reuse).m_input; + reuse = reusable.m_input; } - TermsEnum termsEnum = base.GetIterator(reuse); + TermsEnum termsEnum = base.GetEnumerator(reuse); if (Debugging.AssertsEnabled) Debugging.Assert(termsEnum != null); return new AssertingAtomicReader.AssertingTermsEnum(termsEnum); } @@ -687,7 +694,7 @@ namespace Lucene.Net.Index public override NumericDocValues GetNumericDocValues(string field) { NumericDocValues dv = base.GetNumericDocValues(field); - FieldInfo fi = FieldInfos.FieldInfo(field); + FieldInfo fi = base.FieldInfos.FieldInfo(field); if (dv != null) { if (Debugging.AssertsEnabled) Debugging.Assert(fi != null); @@ -704,7 +711,7 @@ namespace Lucene.Net.Index public override BinaryDocValues GetBinaryDocValues(string field) { BinaryDocValues dv = base.GetBinaryDocValues(field); - FieldInfo fi = FieldInfos.FieldInfo(field); + FieldInfo fi = base.FieldInfos.FieldInfo(field); if (dv != null) { if (Debugging.AssertsEnabled) Debugging.Assert(fi != null); @@ -721,7 +728,7 @@ namespace Lucene.Net.Index public override SortedDocValues GetSortedDocValues(string field) { SortedDocValues dv = base.GetSortedDocValues(field); - FieldInfo fi = FieldInfos.FieldInfo(field); + FieldInfo fi = base.FieldInfos.FieldInfo(field); if (dv != null) { if (Debugging.AssertsEnabled) Debugging.Assert(fi != null); @@ -738,7 +745,7 @@ namespace Lucene.Net.Index public override SortedSetDocValues GetSortedSetDocValues(string field) { SortedSetDocValues dv = base.GetSortedSetDocValues(field); - FieldInfo fi = FieldInfos.FieldInfo(field); + FieldInfo fi = base.FieldInfos.FieldInfo(field); if (dv != null) { if (Debugging.AssertsEnabled) Debugging.Assert(fi != null); @@ -755,7 +762,7 @@ namespace Lucene.Net.Index public override NumericDocValues GetNormValues(string field) { NumericDocValues dv = base.GetNormValues(field); - FieldInfo fi = FieldInfos.FieldInfo(field); + FieldInfo fi = base.FieldInfos.FieldInfo(field); if (dv != null) { if (Debugging.AssertsEnabled) Debugging.Assert(fi != null); @@ -793,7 +800,7 @@ namespace Lucene.Net.Index public override IBits GetDocsWithField(string field) { IBits docsWithField = base.GetDocsWithField(field); - FieldInfo fi = FieldInfos.FieldInfo(field); + FieldInfo fi = base.FieldInfos.FieldInfo(field); if (docsWithField != null) { if (Debugging.AssertsEnabled) Debugging.Assert(fi != null); diff --git a/src/Lucene.Net.Tests/Index/TestFilterAtomicReader.cs b/src/Lucene.Net.Tests/Index/TestFilterAtomicReader.cs index 04d47d9..35b7d26 100644 --- a/src/Lucene.Net.Tests/Index/TestFilterAtomicReader.cs +++ b/src/Lucene.Net.Tests/Index/TestFilterAtomicReader.cs @@ -61,9 +61,14 @@ namespace Lucene.Net.Index { } - public override TermsEnum GetIterator(TermsEnum reuse) + public override TermsEnum GetEnumerator() { - return new TestTermsEnum(base.GetIterator(reuse)); + return new TestTermsEnum(base.GetEnumerator()); + } + + public override TermsEnum GetEnumerator(TermsEnum reuse) + { + return new TestTermsEnum(base.GetEnumerator(reuse)); } } @@ -197,7 +202,12 @@ namespace Lucene.Net.Index { // LUCENENET specific - since we changed to using a property for Attributes rather than a method, // we need to reflect that as get_Attributes here. - if (m.IsStatic || m.IsAbstract || m.IsFinal || /*m.Synthetic ||*/ m.Name.Equals("get_Attributes", StringComparison.Ordinal)) + if (m.IsStatic || m.IsAbstract || m.IsFinal || /*m.Synthetic ||*/ m.Name.Equals("get_Attributes", StringComparison.Ordinal) + + // LUCENENET specific - we only override GetEnumerator(reuse) in specific cases. Also, GetIterator() has a default implementation + // that will be removed before the release. + || m.Name.Equals("GetEnumerator") && m.GetParameters().Length == 1 && m.GetParameters()[0].Name == "reuse" + || m.Name.Equals("GetIterator")) { continue; } diff --git a/src/Lucene.Net/Codecs/BlockTreeTermsReader.cs b/src/Lucene.Net/Codecs/BlockTreeTermsReader.cs index fa8e8d4..fd7e5e9 100644 --- a/src/Lucene.Net/Codecs/BlockTreeTermsReader.cs +++ b/src/Lucene.Net/Codecs/BlockTreeTermsReader.cs @@ -620,7 +620,7 @@ namespace Lucene.Net.Codecs public override bool HasPayloads => fieldInfo.HasPayloads; - public override TermsEnum GetIterator(TermsEnum reuse) + public override TermsEnum GetEnumerator() { return new SegmentTermsEnum(this); } diff --git a/src/Lucene.Net/Codecs/Compressing/CompressingTermVectorsReader.cs b/src/Lucene.Net/Codecs/Compressing/CompressingTermVectorsReader.cs index bd05e44..d2ffc88 100644 --- a/src/Lucene.Net/Codecs/Compressing/CompressingTermVectorsReader.cs +++ b/src/Lucene.Net/Codecs/Compressing/CompressingTermVectorsReader.cs @@ -764,17 +764,21 @@ namespace Lucene.Net.Codecs.Compressing this.termBytes = termBytes; } - public override TermsEnum GetIterator(TermsEnum reuse) + public override TermsEnum GetEnumerator() + { + var termsEnum = new TVTermsEnum(); + termsEnum.Reset(numTerms, flags, prefixLengths, suffixLengths, termFreqs, positionIndex, positions, startOffsets, lengths, payloadIndex, payloadBytes, new ByteArrayDataInput(termBytes.Bytes, termBytes.Offset, termBytes.Length)); + return termsEnum; + } + + public override TermsEnum GetEnumerator(TermsEnum reuse) { TVTermsEnum termsEnum; - if (reuse != null && reuse is TVTermsEnum) - { + if (!(reuse is null) && reuse is TVTermsEnum) termsEnum = (TVTermsEnum)reuse; - } else - { termsEnum = new TVTermsEnum(); - } + termsEnum.Reset(numTerms, flags, prefixLengths, suffixLengths, termFreqs, positionIndex, positions, startOffsets, lengths, payloadIndex, payloadBytes, new ByteArrayDataInput(termBytes.Bytes, termBytes.Offset, termBytes.Length)); return termsEnum; } diff --git a/src/Lucene.Net/Codecs/Lucene3x/Lucene3xFields.cs b/src/Lucene.Net/Codecs/Lucene3x/Lucene3xFields.cs index 62b3fa1..991d5e0 100644 --- a/src/Lucene.Net/Codecs/Lucene3x/Lucene3xFields.cs +++ b/src/Lucene.Net/Codecs/Lucene3x/Lucene3xFields.cs @@ -210,7 +210,7 @@ namespace Lucene.Net.Codecs.Lucene3x this.fieldInfo = fieldInfo; } - public override TermsEnum GetIterator(TermsEnum reuse) + public override TermsEnum GetEnumerator() { var termsEnum = new PreTermsEnum(outerInstance); termsEnum.Reset(fieldInfo); diff --git a/src/Lucene.Net/Codecs/Lucene3x/Lucene3xTermVectorsReader.cs b/src/Lucene.Net/Codecs/Lucene3x/Lucene3xTermVectorsReader.cs index 13af044..819b560 100644 --- a/src/Lucene.Net/Codecs/Lucene3x/Lucene3xTermVectorsReader.cs +++ b/src/Lucene.Net/Codecs/Lucene3x/Lucene3xTermVectorsReader.cs @@ -365,21 +365,31 @@ namespace Lucene.Net.Codecs.Lucene3x unicodeSortOrder = outerInstance.SortTermsByUnicode(); } - public override TermsEnum GetIterator(TermsEnum reuse) + public override TermsEnum GetEnumerator() + { + var termsEnum = new TVTermsEnum(outerInstance); + termsEnum.Reset(numTerms, tvfFPStart, storePositions, storeOffsets, unicodeSortOrder); + return termsEnum; + } + + public override TermsEnum GetEnumerator(TermsEnum reuse) { TVTermsEnum termsEnum; - if (reuse is TVTermsEnum) +#pragma warning disable IDE0038 // Use pattern matching + if (reuse is null || !(reuse is TVTermsEnum)) +#pragma warning restore IDE0038 // Use pattern matching { - termsEnum = (TVTermsEnum)reuse; - if (!termsEnum.CanReuse(outerInstance.tvf)) - { - termsEnum = new TVTermsEnum(outerInstance); - } + termsEnum = new TVTermsEnum(outerInstance); } else { - termsEnum = new TVTermsEnum(outerInstance); + var reusable = (TVTermsEnum)reuse; + if (reusable.CanReuse(outerInstance.tvf)) + termsEnum = reusable; + else + termsEnum = new TVTermsEnum(outerInstance); } + termsEnum.Reset(numTerms, tvfFPStart, storePositions, storeOffsets, unicodeSortOrder); return termsEnum; } diff --git a/src/Lucene.Net/Codecs/Lucene40/Lucene40TermVectorsReader.cs b/src/Lucene.Net/Codecs/Lucene40/Lucene40TermVectorsReader.cs index 6d77867..210ce32 100644 --- a/src/Lucene.Net/Codecs/Lucene40/Lucene40TermVectorsReader.cs +++ b/src/Lucene.Net/Codecs/Lucene40/Lucene40TermVectorsReader.cs @@ -352,21 +352,31 @@ namespace Lucene.Net.Codecs.Lucene40 tvfFPStart = outerInstance.tvf.GetFilePointer(); } - public override TermsEnum GetIterator(TermsEnum reuse) + public override TermsEnum GetEnumerator() + { + var termsEnum = new TVTermsEnum(outerInstance); + termsEnum.Reset(numTerms, tvfFPStart, storePositions, storeOffsets, storePayloads); + return termsEnum; + } + + public override TermsEnum GetEnumerator(TermsEnum reuse) { TVTermsEnum termsEnum; - if (reuse is TVTermsEnum) +#pragma warning disable IDE0038 // Use pattern matching + if (reuse is null || !(reuse is TVTermsEnum)) +#pragma warning restore IDE0038 // Use pattern matching { - termsEnum = (TVTermsEnum)reuse; - if (!termsEnum.CanReuse(outerInstance.tvf)) - { - termsEnum = new TVTermsEnum(outerInstance); - } + termsEnum = new TVTermsEnum(outerInstance); } else { - termsEnum = new TVTermsEnum(outerInstance); + var reusable = (TVTermsEnum)reuse; + if (reusable.CanReuse(outerInstance.tvf)) + termsEnum = reusable; + else + termsEnum = new TVTermsEnum(outerInstance); } + termsEnum.Reset(numTerms, tvfFPStart, storePositions, storeOffsets, storePayloads); return termsEnum; } diff --git a/src/Lucene.Net/Index/FilterAtomicReader.cs b/src/Lucene.Net/Index/FilterAtomicReader.cs index 9dafb1a..11795f5 100644 --- a/src/Lucene.Net/Index/FilterAtomicReader.cs +++ b/src/Lucene.Net/Index/FilterAtomicReader.cs @@ -110,10 +110,9 @@ namespace Lucene.Net.Index this.m_input = input; } - public override TermsEnum GetIterator(TermsEnum reuse) - { - return m_input.GetIterator(reuse); - } + public override TermsEnum GetEnumerator() => m_input.GetEnumerator(); + + public override TermsEnum GetEnumerator(TermsEnum reuse) => m_input.GetEnumerator(reuse); public override IComparer<BytesRef> Comparer => m_input.Comparer; diff --git a/src/Lucene.Net/Index/MultiTerms.cs b/src/Lucene.Net/Index/MultiTerms.cs index da005b9..5843b86 100644 --- a/src/Lucene.Net/Index/MultiTerms.cs +++ b/src/Lucene.Net/Index/MultiTerms.cs @@ -110,12 +110,12 @@ namespace Lucene.Net.Index } } - public override TermsEnum GetIterator(TermsEnum reuse) + public override TermsEnum GetEnumerator() { IList<MultiTermsEnum.TermsEnumIndex> termsEnums = new List<MultiTermsEnum.TermsEnumIndex>(); for (int i = 0; i < subs.Length; i++) { - TermsEnum termsEnum = subs[i].GetIterator(null); + TermsEnum termsEnum = subs[i].GetEnumerator(); if (termsEnum != null) { termsEnums.Add(new MultiTermsEnum.TermsEnumIndex(termsEnum, i)); diff --git a/src/Lucene.Net/Index/Terms.cs b/src/Lucene.Net/Index/Terms.cs index 81187bf..6e0e571 100644 --- a/src/Lucene.Net/Index/Terms.cs +++ b/src/Lucene.Net/Index/Terms.cs @@ -44,18 +44,16 @@ namespace Lucene.Net.Index /// Returns an iterator that will step through all /// terms. This method will not return <c>null</c>. /// </summary> - public virtual TermsEnum GetEnumerator() // LUCENENET specific - Added for .NET compatibility - => GetIterator(null); + public abstract TermsEnum GetEnumerator(); // LUCENENET specific - Refactored to require both overloads, so we don't have a strange null parameter unless needed /// <summary> /// Returns an iterator that will step through all - /// terms. This method will not return <c>null</c>. If you have - /// a previous <see cref="TermsEnum"/>, for example from a different - /// field, you can pass it for possible reuse if the - /// implementation can do so. + /// terms. This method will not return <c>null</c>. /// </summary> - public virtual TermsEnum GetEnumerator(TermsEnum reuse) // LUCENENET specific - Added for .NET compatibility - => GetIterator(reuse); + /// <param name="reuse">If you have a previous <see cref="TermsEnum"/>, + /// for example from a different field, you can pass it for possible + /// reuse if the implementation can do so.</param> + public virtual TermsEnum GetEnumerator(TermsEnum reuse) => GetEnumerator(); // LUCENENET specific - Refactored to require both overloads, so we don't have a strange null parameter unless needed /// <summary> /// Returns an iterator that will step through all @@ -64,7 +62,8 @@ namespace Lucene.Net.Index /// field, you can pass it for possible reuse if the /// implementation can do so. /// </summary> - public abstract TermsEnum GetIterator(TermsEnum reuse); // LUCENENT TODO: API - Mark obsolete/hide + [Obsolete("Use GetEnumerator() or GetEnumerator(TermsEnum). This method will be removed in 4.8.0 release candidate."), System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public virtual TermsEnum GetIterator(TermsEnum reuse) => GetEnumerator(reuse); /// <summary> /// Returns a <see cref="TermsEnum"/> that iterates over all terms that diff --git a/src/Lucene.Net/Search/DocTermOrdsRewriteMethod.cs b/src/Lucene.Net/Search/DocTermOrdsRewriteMethod.cs index 93bd230..88f941f 100644 --- a/src/Lucene.Net/Search/DocTermOrdsRewriteMethod.cs +++ b/src/Lucene.Net/Search/DocTermOrdsRewriteMethod.cs @@ -1,4 +1,5 @@ using Lucene.Net.Diagnostics; +using System; using System.Collections.Generic; namespace Lucene.Net.Search @@ -98,7 +99,7 @@ namespace Lucene.Net.Search SortedSetDocValues docTermOrds = FieldCache.DEFAULT.GetDocTermOrds((context.AtomicReader), m_query.m_field); // Cannot use FixedBitSet because we require long index (ord): Int64BitSet termSet = new Int64BitSet(docTermOrds.ValueCount); - TermsEnum termsEnum = m_query.GetTermsEnum(new TermsAnonymousInnerClassHelper(this, docTermOrds)); + TermsEnum termsEnum = m_query.GetTermsEnum(new TermsAnonymousInnerClassHelper(docTermOrds)); if (Debugging.AssertsEnabled) Debugging.Assert(termsEnum != null); if (termsEnum.MoveNext()) @@ -131,19 +132,16 @@ namespace Lucene.Net.Search private class TermsAnonymousInnerClassHelper : Terms { - private readonly MultiTermQueryDocTermOrdsWrapperFilter outerInstance; + private readonly SortedSetDocValues docTermOrds; - private SortedSetDocValues docTermOrds; - - public TermsAnonymousInnerClassHelper(MultiTermQueryDocTermOrdsWrapperFilter outerInstance, SortedSetDocValues docTermOrds) + public TermsAnonymousInnerClassHelper(SortedSetDocValues docTermOrds) { - this.outerInstance = outerInstance; this.docTermOrds = docTermOrds; } public override IComparer<BytesRef> Comparer => BytesRef.UTF8SortedAsUnicodeComparer; - public override TermsEnum GetIterator(TermsEnum reuse) + public override TermsEnum GetEnumerator() { return docTermOrds.GetTermsEnum(); } diff --git a/src/Lucene.Net/Search/FieldCacheRewriteMethod.cs b/src/Lucene.Net/Search/FieldCacheRewriteMethod.cs index bcc9cba..65653d5 100644 --- a/src/Lucene.Net/Search/FieldCacheRewriteMethod.cs +++ b/src/Lucene.Net/Search/FieldCacheRewriteMethod.cs @@ -1,4 +1,5 @@ using Lucene.Net.Diagnostics; +using System; using System.Collections.Generic; namespace Lucene.Net.Search @@ -140,10 +141,7 @@ namespace Lucene.Net.Search public override IComparer<BytesRef> Comparer => BytesRef.UTF8SortedAsUnicodeComparer; - public override TermsEnum GetIterator(TermsEnum reuse) - { - return fcsi.GetTermsEnum(); - } + public override TermsEnum GetEnumerator() => fcsi.GetTermsEnum(); public override long SumTotalTermFreq => -1;
