lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nightowl...@apache.org
Subject [3/5] lucenenet git commit: Lucene.Net.Core.Index.Terms refactor: Renamed Iterator() > GetIterator()
Date Thu, 26 Jan 2017 05:28:09 GMT
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.TestFramework/Util/TestUtil.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.TestFramework/Util/TestUtil.cs b/src/Lucene.Net.TestFramework/Util/TestUtil.cs
index 398e5e0..85ff2d9 100644
--- a/src/Lucene.Net.TestFramework/Util/TestUtil.cs
+++ b/src/Lucene.Net.TestFramework/Util/TestUtil.cs
@@ -1098,7 +1098,7 @@ namespace Lucene.Net.Util
             {
                 return null;
             }
-            TermsEnum termsEnum = terms.Iterator(null);
+            TermsEnum termsEnum = terms.GetIterator(null);
             if (!termsEnum.SeekExact(term))
             {
                 return null;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests.Analysis.Common/Analysis/Sinks/TestTeeSinkTokenFilter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Sinks/TestTeeSinkTokenFilter.cs b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Sinks/TestTeeSinkTokenFilter.cs
index 781fe0e..161c3b9 100644
--- a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Sinks/TestTeeSinkTokenFilter.cs
+++ b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Sinks/TestTeeSinkTokenFilter.cs
@@ -116,7 +116,7 @@ namespace Lucene.Net.Analysis.Sinks
             IndexReader r = DirectoryReader.Open(dir);
             Terms vector = r.GetTermVectors(0).Terms("field");
             assertEquals(1, vector.Count);
-            TermsEnum termsEnum = vector.Iterator(null);
+            TermsEnum termsEnum = vector.GetIterator(null);
             termsEnum.Next();
             assertEquals(2, termsEnum.TotalTermFreq);
             DocsAndPositionsEnum positions = termsEnum.DocsAndPositions(null, null);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests.Codecs/Pulsing/Test10KPulsings.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Codecs/Pulsing/Test10KPulsings.cs b/src/Lucene.Net.Tests.Codecs/Pulsing/Test10KPulsings.cs
index 1bd88c8..64f66a0 100644
--- a/src/Lucene.Net.Tests.Codecs/Pulsing/Test10KPulsings.cs
+++ b/src/Lucene.Net.Tests.Codecs/Pulsing/Test10KPulsings.cs
@@ -79,7 +79,7 @@ namespace Lucene.Net.Codecs.Pulsing
             IndexReader ir = iw.Reader;
             iw.Dispose();
 
-            TermsEnum te = MultiFields.GetTerms(ir, "field").Iterator(null);
+            TermsEnum te = MultiFields.GetTerms(ir, "field").GetIterator(null);
             DocsEnum de = null;
 
             for (int i = 0; i < 10050; i++)
@@ -151,7 +151,7 @@ namespace Lucene.Net.Codecs.Pulsing
             IndexReader ir = iw.Reader;
             iw.Dispose();
 
-            TermsEnum te = MultiFields.GetTerms(ir, "field").Iterator(null);
+            TermsEnum te = MultiFields.GetTerms(ir, "field").GetIterator(null);
             DocsEnum de = null;
 
             for (int i = 0; i < 10050; i++)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests.Codecs/Pulsing/TestPulsingReuse.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Codecs/Pulsing/TestPulsingReuse.cs b/src/Lucene.Net.Tests.Codecs/Pulsing/TestPulsingReuse.cs
index b6cc5ba..d711b1d 100644
--- a/src/Lucene.Net.Tests.Codecs/Pulsing/TestPulsingReuse.cs
+++ b/src/Lucene.Net.Tests.Codecs/Pulsing/TestPulsingReuse.cs
@@ -49,7 +49,7 @@ namespace Lucene.Net.Codecs.Pulsing
             AtomicReader segment = GetOnlySegmentReader(ir);
             DocsEnum reuse = null;
             IDictionary<DocsEnum, bool?> allEnums = new IdentityHashMap<DocsEnum, bool?>();
-            TermsEnum te = segment.Terms("foo").Iterator(null);
+            TermsEnum te = segment.Terms("foo").GetIterator(null);
             while (te.Next() != null)
             {
                 reuse = te.Docs(null, reuse, DocsEnum.FLAG_NONE);
@@ -60,7 +60,7 @@ namespace Lucene.Net.Codecs.Pulsing
 
             allEnums.Clear();
             DocsAndPositionsEnum posReuse = null;
-            te = segment.Terms("foo").Iterator(null);
+            te = segment.Terms("foo").GetIterator(null);
             while (te.Next() != null)
             {
                 posReuse = te.DocsAndPositions(null, posReuse);
@@ -94,7 +94,7 @@ namespace Lucene.Net.Codecs.Pulsing
             AtomicReader segment = GetOnlySegmentReader(ir);
             DocsEnum reuse = null;
             IDictionary<DocsEnum, bool?> allEnums = new IdentityHashMap<DocsEnum, bool?>();
-            TermsEnum te = segment.Terms("foo").Iterator(null);
+            TermsEnum te = segment.Terms("foo").GetIterator(null);
             while (te.Next() != null)
             {
                 reuse = te.Docs(null, reuse, DocsEnum.FLAG_NONE);
@@ -105,7 +105,7 @@ namespace Lucene.Net.Codecs.Pulsing
 
             allEnums.Clear();
             DocsAndPositionsEnum posReuse = null;
-            te = segment.Terms("foo").Iterator(null);
+            te = segment.Terms("foo").GetIterator(null);
             while (te.Next() != null)
             {
                 posReuse = te.DocsAndPositions(null, posReuse);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests.Join/TestJoinUtil.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Join/TestJoinUtil.cs b/src/Lucene.Net.Tests.Join/TestJoinUtil.cs
index 5abdec0..274a588 100644
--- a/src/Lucene.Net.Tests.Join/TestJoinUtil.cs
+++ b/src/Lucene.Net.Tests.Join/TestJoinUtil.cs
@@ -717,7 +717,7 @@ namespace Lucene.Net.Tests.Join
                             joinValues.AddAll(joinValueToJoinScores.Keys);
                             foreach (BytesRef joinValue in joinValues)
                             {
-                                termsEnum = terms.Iterator(termsEnum);
+                                termsEnum = terms.GetIterator(termsEnum);
                                 if (termsEnum.SeekExact(joinValue))
                                 {
                                     docsEnum = termsEnum.Docs(slowCompositeReader.LiveDocs, docsEnum, DocsEnum.FLAG_NONE);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests.Memory/Index/Memory/MemoryIndexTest.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Memory/Index/Memory/MemoryIndexTest.cs b/src/Lucene.Net.Tests.Memory/Index/Memory/MemoryIndexTest.cs
index f9469d4..82720b0 100644
--- a/src/Lucene.Net.Tests.Memory/Index/Memory/MemoryIndexTest.cs
+++ b/src/Lucene.Net.Tests.Memory/Index/Memory/MemoryIndexTest.cs
@@ -152,8 +152,8 @@ namespace Lucene.Net.Index.Memory
                     assertEquals(iwTerms.DocCount, memTerms.DocCount);
                     assertEquals(iwTerms.SumDocFreq, memTerms.SumDocFreq);
                     assertEquals(iwTerms.SumTotalTermFreq, memTerms.SumTotalTermFreq);
-                    TermsEnum iwTermsIter = iwTerms.Iterator(null);
-                    TermsEnum memTermsIter = memTerms.Iterator(null);
+                    TermsEnum iwTermsIter = iwTerms.GetIterator(null);
+                    TermsEnum memTermsIter = memTerms.GetIterator(null);
                     if (iwTerms.HasPositions)
                     {
                         bool offsets = iwTerms.HasOffsets && memTerms.HasOffsets;
@@ -328,7 +328,7 @@ namespace Lucene.Net.Index.Memory
             assertTrue(disi.NextDoc() != DocIdSetIterator.NO_MORE_DOCS);
 
             // now reuse and check again
-            TermsEnum te = reader.Terms("foo").Iterator(null);
+            TermsEnum te = reader.Terms("foo").GetIterator(null);
             assertTrue(te.SeekExact(new BytesRef("bar")));
             disi = te.Docs(null, disi, DocsEnum.FLAG_NONE);
             docid = disi.DocID;
@@ -369,7 +369,7 @@ namespace Lucene.Net.Index.Memory
                 assertEquals(3, disi.EndOffset);
 
                 // now reuse and check again
-                TermsEnum te = reader.Terms("foo").Iterator(null);
+                TermsEnum te = reader.Terms("foo").GetIterator(null);
                 assertTrue(te.SeekExact(new BytesRef("bar")));
                 disi = te.DocsAndPositions(null, disi);
                 docid = disi.DocID;
@@ -546,8 +546,8 @@ namespace Lucene.Net.Index.Memory
         protected void CompareTermVectors(Terms terms, Terms memTerms, string field_name)
         {
 
-            TermsEnum termEnum = terms.Iterator(null);
-            TermsEnum memTermEnum = memTerms.Iterator(null);
+            TermsEnum termEnum = terms.GetIterator(null);
+            TermsEnum memTermEnum = memTerms.GetIterator(null);
 
             while (termEnum.Next() != null)
             {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests.Misc/Index/Sorter/SorterTestBase.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Misc/Index/Sorter/SorterTestBase.cs b/src/Lucene.Net.Tests.Misc/Index/Sorter/SorterTestBase.cs
index 7b56abb..793aaaa 100644
--- a/src/Lucene.Net.Tests.Misc/Index/Sorter/SorterTestBase.cs
+++ b/src/Lucene.Net.Tests.Misc/Index/Sorter/SorterTestBase.cs
@@ -245,7 +245,7 @@ namespace Lucene.Net.Index.Sorter
         // [Test] // LUCENENET NOTE: For now, we are overriding this test in every subclass to pull it into the right context for the subclass
         public virtual void TestDocsAndPositionsEnum()
         {
-            TermsEnum termsEnum = reader.Terms(DOC_POSITIONS_FIELD).Iterator(null);
+            TermsEnum termsEnum = reader.Terms(DOC_POSITIONS_FIELD).GetIterator(null);
             assertEquals(TermsEnum.SeekStatus.FOUND, termsEnum.SeekCeil(new BytesRef(DOC_POSITIONS_TERM)));
             DocsAndPositionsEnum sortedPositions = termsEnum.DocsAndPositions(null, null);
             int doc;
@@ -326,7 +326,7 @@ namespace Lucene.Net.Index.Sorter
         public virtual void TestDocsEnum()
         {
             IBits mappedLiveDocs = RandomLiveDocs(reader.MaxDoc);
-            TermsEnum termsEnum = reader.Terms(DOCS_ENUM_FIELD).Iterator(null);
+            TermsEnum termsEnum = reader.Terms(DOCS_ENUM_FIELD).GetIterator(null);
             assertEquals(TermsEnum.SeekStatus.FOUND, termsEnum.SeekCeil(new BytesRef(DOCS_ENUM_TERM)));
             DocsEnum docs = termsEnum.Docs(mappedLiveDocs, null);
 
@@ -431,7 +431,7 @@ namespace Lucene.Net.Index.Sorter
             {
                 Terms terms = reader.GetTermVector(i, TERM_VECTORS_FIELD);
                 assertNotNull("term vectors not found for doc " + i + " field [" + TERM_VECTORS_FIELD + "]", terms);
-                assertEquals("incorrect term vector for doc " + i, sortedValues[i].toString(), terms.Iterator(null).Next().Utf8ToString());
+                assertEquals("incorrect term vector for doc " + i, sortedValues[i].toString(), terms.GetIterator(null).Next().Utf8ToString());
             }
         }
     }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests.Misc/Index/TestMultiPassIndexSplitter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Misc/Index/TestMultiPassIndexSplitter.cs b/src/Lucene.Net.Tests.Misc/Index/TestMultiPassIndexSplitter.cs
index f949d95..c03719c 100644
--- a/src/Lucene.Net.Tests.Misc/Index/TestMultiPassIndexSplitter.cs
+++ b/src/Lucene.Net.Tests.Misc/Index/TestMultiPassIndexSplitter.cs
@@ -81,7 +81,7 @@ namespace Lucene.Net.Index
                     assertTrue(ir.NumDocs - NUM_DOCS / 3 <= 1); // rounding error
                     doc = ir.Document(0);
                     assertEquals("0", doc.Get("id"));
-                    te = MultiFields.GetTerms(ir, "id").Iterator(null);
+                    te = MultiFields.GetTerms(ir, "id").GetIterator(null);
                     assertEquals(TermsEnum.SeekStatus.NOT_FOUND, te.SeekCeil(new BytesRef("1")));
                     assertNotSame("1", te.Term.Utf8ToString());
                 }
@@ -90,7 +90,7 @@ namespace Lucene.Net.Index
                     assertTrue(ir.NumDocs - NUM_DOCS / 3 <= 1);
                     doc = ir.Document(0);
                     assertEquals("1", doc.Get("id"));
-                    te = MultiFields.GetTerms(ir, "id").Iterator(null);
+                    te = MultiFields.GetTerms(ir, "id").GetIterator(null);
                     assertEquals(TermsEnum.SeekStatus.NOT_FOUND, te.SeekCeil(new BytesRef("0")));
 
                     assertNotSame("0", te.Term.Utf8ToString());
@@ -101,7 +101,7 @@ namespace Lucene.Net.Index
                     doc = ir.Document(0);
                     assertEquals("2", doc.Get("id"));
 
-                    te = MultiFields.GetTerms(ir, "id").Iterator(null);
+                    te = MultiFields.GetTerms(ir, "id").GetIterator(null);
                     assertEquals(TermsEnum.SeekStatus.NOT_FOUND, te.SeekCeil(new BytesRef("1")));
                     assertNotSame("1", te.Term);
 
@@ -156,7 +156,7 @@ namespace Lucene.Net.Index
                     doc = ir.Document(0);
                     assertEquals(start + "", doc.Get("id"));
                     // make sure the deleted doc is not here
-                    TermsEnum te = MultiFields.GetTerms(ir, "id").Iterator(null);
+                    TermsEnum te = MultiFields.GetTerms(ir, "id").GetIterator(null);
                     Term t = new Term("id", (NUM_DOCS - 1) + "");
                     assertEquals(TermsEnum.SeekStatus.NOT_FOUND, te.SeekCeil(new BytesRef(t.Text())));
                     assertNotSame(t.Text(), te.Term.Utf8ToString());

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Analysis/TestMockAnalyzer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Analysis/TestMockAnalyzer.cs b/src/Lucene.Net.Tests/core/Analysis/TestMockAnalyzer.cs
index 72a63f3..d1f429c 100644
--- a/src/Lucene.Net.Tests/core/Analysis/TestMockAnalyzer.cs
+++ b/src/Lucene.Net.Tests/core/Analysis/TestMockAnalyzer.cs
@@ -368,7 +368,7 @@ namespace Lucene.Net.Analysis
             AtomicReader reader = GetOnlySegmentReader(writer.Reader);
             Fields fields = reader.GetTermVectors(0);
             Terms terms = fields.Terms("f");
-            TermsEnum te = terms.Iterator(null);
+            TermsEnum te = terms.GetIterator(null);
             Assert.AreEqual(new BytesRef("a"), te.Next());
             DocsAndPositionsEnum dpe = te.DocsAndPositions(null, null);
             Assert.AreEqual(0, dpe.NextDoc());

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Codecs/Compressing/TestCompressingTermVectorsFormat.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Codecs/Compressing/TestCompressingTermVectorsFormat.cs b/src/Lucene.Net.Tests/core/Codecs/Compressing/TestCompressingTermVectorsFormat.cs
index a5b5181..1ce3276 100644
--- a/src/Lucene.Net.Tests/core/Codecs/Compressing/TestCompressingTermVectorsFormat.cs
+++ b/src/Lucene.Net.Tests/core/Codecs/Compressing/TestCompressingTermVectorsFormat.cs
@@ -60,7 +60,7 @@ namespace Lucene.Net.Codecs.Compressing
             AtomicReader ir = GetOnlySegmentReader(iw.Reader);
             Terms terms = ir.GetTermVector(0, "foo");
             Assert.IsNotNull(terms);
-            TermsEnum termsEnum = terms.Iterator(null);
+            TermsEnum termsEnum = terms.GetIterator(null);
             Assert.AreEqual(TermsEnum.SeekStatus.FOUND, termsEnum.SeekCeil(new BytesRef("this")));
             try
             {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Codecs/Lucene3x/TestSurrogates.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Codecs/Lucene3x/TestSurrogates.cs b/src/Lucene.Net.Tests/core/Codecs/Lucene3x/TestSurrogates.cs
index e24025d..01fa90f 100644
--- a/src/Lucene.Net.Tests/core/Codecs/Lucene3x/TestSurrogates.cs
+++ b/src/Lucene.Net.Tests/core/Codecs/Lucene3x/TestSurrogates.cs
@@ -139,7 +139,7 @@ namespace Lucene.Net.Codecs.Lucene3x
                 {
                     Terms terms = fields.Terms(field);
                     Assert.IsNotNull(terms);
-                    TermsEnum termsEnum = terms.Iterator(null);
+                    TermsEnum termsEnum = terms.GetIterator(null);
                     BytesRef text;
                     BytesRef lastText = null;
                     while ((text = termsEnum.Next()) != null)
@@ -202,7 +202,7 @@ namespace Lucene.Net.Codecs.Lucene3x
                 TermsEnum te;
                 if (!tes.TryGetValue(field, out te))
                 {
-                    te = MultiFields.GetTerms(reader, field).Iterator(null);
+                    te = MultiFields.GetTerms(reader, field).GetIterator(null);
                     tes[field] = te;
                 }
 
@@ -278,7 +278,7 @@ namespace Lucene.Net.Codecs.Lucene3x
                         TermsEnum te;
                         if (!tes.TryGetValue(field, out te))
                         {
-                            te = MultiFields.GetTerms(reader, field).Iterator(null);
+                            te = MultiFields.GetTerms(reader, field).GetIterator(null);
                             tes[field] = te;
                         }
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Codecs/Lucene3x/TestTermInfosReaderIndex.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Codecs/Lucene3x/TestTermInfosReaderIndex.cs b/src/Lucene.Net.Tests/core/Codecs/Lucene3x/TestTermInfosReaderIndex.cs
index dd48238..f6aa8a8 100644
--- a/src/Lucene.Net.Tests/core/Codecs/Lucene3x/TestTermInfosReaderIndex.cs
+++ b/src/Lucene.Net.Tests/core/Codecs/Lucene3x/TestTermInfosReaderIndex.cs
@@ -171,7 +171,7 @@ namespace Lucene.Net.Codecs.Lucene3x
             {
                 Terms terms = fields.Terms(field);
                 Assert.IsNotNull(terms);
-                TermsEnum termsEnum = terms.Iterator(null);
+                TermsEnum termsEnum = terms.GetIterator(null);
                 while (termsEnum.Next() != null)
                 {
                     if (sample.Count >= size)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Codecs/Lucene40/TestReuseDocsEnum.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Codecs/Lucene40/TestReuseDocsEnum.cs b/src/Lucene.Net.Tests/core/Codecs/Lucene40/TestReuseDocsEnum.cs
index 0c576c5..556a013 100644
--- a/src/Lucene.Net.Tests/core/Codecs/Lucene40/TestReuseDocsEnum.cs
+++ b/src/Lucene.Net.Tests/core/Codecs/Lucene40/TestReuseDocsEnum.cs
@@ -71,7 +71,7 @@ namespace Lucene.Net.Codecs.Lucene40
             {
                 AtomicReader indexReader = (AtomicReader)ctx.Reader;
                 Terms terms = indexReader.Terms("body");
-                TermsEnum iterator = terms.Iterator(null);
+                TermsEnum iterator = terms.GetIterator(null);
                 IdentityHashMap<DocsEnum, bool?> enums = new IdentityHashMap<DocsEnum, bool?>();
                 MatchNoBits bits = new MatchNoBits(indexReader.MaxDoc);
                 while ((iterator.Next()) != null)
@@ -100,7 +100,7 @@ namespace Lucene.Net.Codecs.Lucene40
             foreach (AtomicReaderContext ctx in open.Leaves)
             {
                 Terms terms = ((AtomicReader)ctx.Reader).Terms("body");
-                TermsEnum iterator = terms.Iterator(null);
+                TermsEnum iterator = terms.GetIterator(null);
                 IdentityHashMap<DocsEnum, bool?> enums = new IdentityHashMap<DocsEnum, bool?>();
                 MatchNoBits bits = new MatchNoBits(open.MaxDoc);
                 DocsEnum docs = null;
@@ -112,7 +112,7 @@ namespace Lucene.Net.Codecs.Lucene40
 
                 Assert.AreEqual(1, enums.Count);
                 enums.Clear();
-                iterator = terms.Iterator(null);
+                iterator = terms.GetIterator(null);
                 docs = null;
                 while ((iterator.Next()) != null)
                 {
@@ -122,7 +122,7 @@ namespace Lucene.Net.Codecs.Lucene40
                 Assert.AreEqual(terms.Count, enums.Count);
 
                 enums.Clear();
-                iterator = terms.Iterator(null);
+                iterator = terms.GetIterator(null);
                 docs = null;
                 while ((iterator.Next()) != null)
                 {
@@ -156,10 +156,10 @@ namespace Lucene.Net.Codecs.Lucene40
             foreach (AtomicReaderContext ctx in leaves)
             {
                 Terms terms = ((AtomicReader)ctx.Reader).Terms("body");
-                TermsEnum iterator = terms.Iterator(null);
+                TermsEnum iterator = terms.GetIterator(null);
                 IdentityHashMap<DocsEnum, bool?> enums = new IdentityHashMap<DocsEnum, bool?>();
                 MatchNoBits bits = new MatchNoBits(firstReader.MaxDoc);
-                iterator = terms.Iterator(null);
+                iterator = terms.GetIterator(null);
                 DocsEnum docs = null;
                 BytesRef term = null;
                 while ((term = iterator.Next()) != null)
@@ -169,7 +169,7 @@ namespace Lucene.Net.Codecs.Lucene40
                 }
                 Assert.AreEqual(terms.Count, enums.Count);
 
-                iterator = terms.Iterator(null);
+                iterator = terms.GetIterator(null);
                 enums.Clear();
                 docs = null;
                 while ((term = iterator.Next()) != null)
@@ -194,7 +194,7 @@ namespace Lucene.Net.Codecs.Lucene40
             {
                 return null;
             }
-            TermsEnum iterator = terms.Iterator(null);
+            TermsEnum iterator = terms.GetIterator(null);
             if (iterator.SeekExact(term))
             {
                 return iterator.Docs(bits, null, Random().NextBoolean() ? DocsEnum.FLAG_FREQS : DocsEnum.FLAG_NONE);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Codecs/Lucene41/TestBlockPostingsFormat3.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Codecs/Lucene41/TestBlockPostingsFormat3.cs b/src/Lucene.Net.Tests/core/Codecs/Lucene41/TestBlockPostingsFormat3.cs
index f9cdc88..1e14bba 100644
--- a/src/Lucene.Net.Tests/core/Codecs/Lucene41/TestBlockPostingsFormat3.cs
+++ b/src/Lucene.Net.Tests/core/Codecs/Lucene41/TestBlockPostingsFormat3.cs
@@ -205,8 +205,8 @@ namespace Lucene.Net.Codecs.Lucene41
 
             // NOTE: we don't assert hasOffsets/hasPositions/hasPayloads because they are allowed to be different
 
-            TermsEnum leftTermsEnum = leftTerms.Iterator(null);
-            TermsEnum rightTermsEnum = rightTerms.Iterator(null);
+            TermsEnum leftTermsEnum = leftTerms.GetIterator(null);
+            TermsEnum rightTermsEnum = rightTerms.GetIterator(null);
             AssertTermsEnum(leftTermsEnum, rightTermsEnum, true);
 
             AssertTermsSeeking(leftTerms, rightTerms);
@@ -243,7 +243,7 @@ namespace Lucene.Net.Codecs.Lucene41
             int numPasses = 0;
             while (numPasses < 10 && tests.Count < numTests)
             {
-                leftEnum = leftTerms.Iterator(leftEnum);
+                leftEnum = leftTerms.GetIterator(leftEnum);
                 BytesRef term = null;
                 while ((term = leftEnum.Next()) != null)
                 {
@@ -279,8 +279,8 @@ namespace Lucene.Net.Codecs.Lucene41
 
             foreach (BytesRef b in shuffledTests)
             {
-                leftEnum = leftTerms.Iterator(leftEnum);
-                rightEnum = rightTerms.Iterator(rightEnum);
+                leftEnum = leftTerms.GetIterator(leftEnum);
+                rightEnum = rightTerms.GetIterator(rightEnum);
 
                 Assert.AreEqual(leftEnum.SeekExact(b), rightEnum.SeekExact(b));
                 Assert.AreEqual(leftEnum.SeekExact(b), rightEnum.SeekExact(b));

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Document/TestDocument.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Document/TestDocument.cs b/src/Lucene.Net.Tests/core/Document/TestDocument.cs
index 0f30dc4..3e51b12 100644
--- a/src/Lucene.Net.Tests/core/Document/TestDocument.cs
+++ b/src/Lucene.Net.Tests/core/Document/TestDocument.cs
@@ -409,7 +409,7 @@ namespace Lucene.Net.Documents
                 Terms tvs = tvFields.Terms(field);
                 Assert.IsNotNull(tvs);
                 Assert.AreEqual(2, tvs.Count);
-                TermsEnum tvsEnum = tvs.Iterator(null);
+                TermsEnum tvsEnum = tvs.GetIterator(null);
                 Assert.AreEqual(new BytesRef("abc"), tvsEnum.Next());
                 DocsAndPositionsEnum dpEnum = tvsEnum.DocsAndPositions(null, null);
                 if (field.Equals("tv"))

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Index/Test2BTerms.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/Test2BTerms.cs b/src/Lucene.Net.Tests/core/Index/Test2BTerms.cs
index bb15720..3111892 100644
--- a/src/Lucene.Net.Tests/core/Index/Test2BTerms.cs
+++ b/src/Lucene.Net.Tests/core/Index/Test2BTerms.cs
@@ -260,7 +260,7 @@ namespace Lucene.Net.Index
         private IList<BytesRef> FindTerms(IndexReader r)
         {
             Console.WriteLine("TEST: findTerms");
-            TermsEnum termsEnum = MultiFields.GetTerms(r, "field").Iterator(null);
+            TermsEnum termsEnum = MultiFields.GetTerms(r, "field").GetIterator(null);
             IList<BytesRef> savedTerms = new List<BytesRef>();
             int nextSave = TestUtil.NextInt(Random(), 500000, 1000000);
             BytesRef term;
@@ -281,7 +281,7 @@ namespace Lucene.Net.Index
             Console.WriteLine("TEST: run " + terms.Count + " terms on reader=" + r);
             IndexSearcher s = NewSearcher(r);
             terms = CollectionsHelper.Shuffle(terms);
-            TermsEnum termsEnum = MultiFields.GetTerms(r, "field").Iterator(null);
+            TermsEnum termsEnum = MultiFields.GetTerms(r, "field").GetIterator(null);
             bool failed = false;
             for (int iter = 0; iter < 10 * terms.Count; iter++)
             {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Index/TestBackwardsCompatibility.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestBackwardsCompatibility.cs b/src/Lucene.Net.Tests/core/Index/TestBackwardsCompatibility.cs
index 0ca5bf9..33c858a 100644
--- a/src/Lucene.Net.Tests/core/Index/TestBackwardsCompatibility.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestBackwardsCompatibility.cs
@@ -787,7 +787,7 @@ namespace Lucene.Net.Index
             {
                 Directory dir = OldIndexDirs[name];
                 IndexReader r = DirectoryReader.Open(dir);
-                TermsEnum terms = MultiFields.GetFields(r).Terms("content").Iterator(null);
+                TermsEnum terms = MultiFields.GetFields(r).Terms("content").GetIterator(null);
                 BytesRef t = terms.Next();
                 Assert.IsNotNull(t);
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Index/TestBackwardsCompatibility3x.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestBackwardsCompatibility3x.cs b/src/Lucene.Net.Tests/core/Index/TestBackwardsCompatibility3x.cs
index 50e8b43..8f27199 100644
--- a/src/Lucene.Net.Tests/core/Index/TestBackwardsCompatibility3x.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestBackwardsCompatibility3x.cs
@@ -744,7 +744,7 @@ namespace Lucene.Net.Index
             {
                 Directory dir = OldIndexDirs[name];
                 IndexReader r = DirectoryReader.Open(dir);
-                TermsEnum terms = MultiFields.GetFields(r).Terms("content").Iterator(null);
+                TermsEnum terms = MultiFields.GetFields(r).Terms("content").GetIterator(null);
                 BytesRef t = terms.Next();
                 Assert.IsNotNull(t);
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Index/TestBagOfPositions.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestBagOfPositions.cs b/src/Lucene.Net.Tests/core/Index/TestBagOfPositions.cs
index 4797fb4..782b24c 100644
--- a/src/Lucene.Net.Tests/core/Index/TestBagOfPositions.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestBagOfPositions.cs
@@ -136,7 +136,7 @@ namespace Lucene.Net.Index
             Terms terms = air.Terms("field");
             // numTerms-1 because there cannot be a term 0 with 0 postings:
             Assert.AreEqual(numTerms - 1, terms.Count);
-            TermsEnum termsEnum = terms.Iterator(null);
+            TermsEnum termsEnum = terms.GetIterator(null);
             BytesRef termBR;
             while ((termBR = termsEnum.Next()) != null)
             {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Index/TestBagOfPostings.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestBagOfPostings.cs b/src/Lucene.Net.Tests/core/Index/TestBagOfPostings.cs
index 607961b..f8f6c5f 100644
--- a/src/Lucene.Net.Tests/core/Index/TestBagOfPostings.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestBagOfPostings.cs
@@ -117,7 +117,7 @@ namespace Lucene.Net.Index
             {
                 Assert.AreEqual(numTerms - 1, terms.Count);
             }
-            TermsEnum termsEnum = terms.Iterator(null);
+            TermsEnum termsEnum = terms.GetIterator(null);
             BytesRef term_;
             while ((term_ = termsEnum.Next()) != null)
             {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Index/TestCodecs.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestCodecs.cs b/src/Lucene.Net.Tests/core/Index/TestCodecs.cs
index 4247869..f9b4b68 100644
--- a/src/Lucene.Net.Tests/core/Index/TestCodecs.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestCodecs.cs
@@ -407,7 +407,7 @@ namespace Lucene.Net.Index
             Terms terms2 = reader.Terms(fieldName);
             Assert.IsNotNull(terms2);
 
-            TermsEnum termsEnum = terms2.Iterator(null);
+            TermsEnum termsEnum = terms2.GetIterator(null);
 
             DocsEnum docsEnum = null;
             for (int i = 0; i < NUM_TERMS; i++)
@@ -629,7 +629,7 @@ namespace Lucene.Net.Index
                 for (int iter = 0; iter < NUM_TEST_ITER; iter++)
                 {
                     FieldData field = Fields[Random().Next(Fields.Length)];
-                    TermsEnum termsEnum = TermsDict.Terms(field.FieldInfo.Name).Iterator(null);
+                    TermsEnum termsEnum = TermsDict.Terms(field.FieldInfo.Name).GetIterator(null);
 #pragma warning disable 612, 618
                     if (Si.Codec is Lucene3xCodec)
 #pragma warning restore 612, 618

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Index/TestDirectoryReader.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestDirectoryReader.cs b/src/Lucene.Net.Tests/core/Index/TestDirectoryReader.cs
index 39a094d..ee4a8b6 100644
--- a/src/Lucene.Net.Tests/core/Index/TestDirectoryReader.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestDirectoryReader.cs
@@ -99,11 +99,11 @@ namespace Lucene.Net.Index
             MultiReader mr3 = new MultiReader(readers2);
 
             // test mixing up TermDocs and TermEnums from different readers.
-            TermsEnum te2 = MultiFields.GetTerms(mr2, "body").Iterator(null);
+            TermsEnum te2 = MultiFields.GetTerms(mr2, "body").GetIterator(null);
             te2.SeekCeil(new BytesRef("wow"));
             DocsEnum td = TestUtil.Docs(Random(), mr2, "body", te2.Term, MultiFields.GetLiveDocs(mr2), null, 0);
 
-            TermsEnum te3 = MultiFields.GetTerms(mr3, "body").Iterator(null);
+            TermsEnum te3 = MultiFields.GetTerms(mr3, "body").GetIterator(null);
             te3.SeekCeil(new BytesRef("wow"));
             td = TestUtil.Docs(Random(), te3, MultiFields.GetLiveDocs(mr3), td, 0);
 
@@ -668,11 +668,11 @@ namespace Lucene.Net.Index
                     Assert.IsNull(fields2.Terms(field1));
                     continue;
                 }
-                TermsEnum enum1 = terms1.Iterator(null);
+                TermsEnum enum1 = terms1.GetIterator(null);
 
                 Terms terms2 = fields2.Terms(field1);
                 Assert.IsNotNull(terms2);
-                TermsEnum enum2 = terms2.Iterator(null);
+                TermsEnum enum2 = terms2.GetIterator(null);
 
                 while (enum1.Next() != null)
                 {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Index/TestDoc.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestDoc.cs b/src/Lucene.Net.Tests/core/Index/TestDoc.cs
index 763a439..482c3ec 100644
--- a/src/Lucene.Net.Tests/core/Index/TestDoc.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestDoc.cs
@@ -249,7 +249,7 @@ namespace Lucene.Net.Index
             {
                 Terms terms = fields.Terms(field);
                 Assert.IsNotNull(terms);
-                TermsEnum tis = terms.Iterator(null);
+                TermsEnum tis = terms.GetIterator(null);
                 while (tis.Next() != null)
                 {
                     @out.Write("  term=" + field + ":" + tis.Term);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Index/TestDocCount.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestDocCount.cs b/src/Lucene.Net.Tests/core/Index/TestDocCount.cs
index 025c31f..6322786 100644
--- a/src/Lucene.Net.Tests/core/Index/TestDocCount.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestDocCount.cs
@@ -85,7 +85,7 @@ namespace Lucene.Net.Index
                 }
                 int docCount = terms.DocCount;
                 FixedBitSet visited = new FixedBitSet(ir.MaxDoc);
-                TermsEnum te = terms.Iterator(null);
+                TermsEnum te = terms.GetIterator(null);
                 while (te.Next() != null)
                 {
                     DocsEnum de = TestUtil.Docs(Random(), te, null, null, DocsEnum.FLAG_NONE);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Index/TestDocTermOrds.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestDocTermOrds.cs b/src/Lucene.Net.Tests/core/Index/TestDocTermOrds.cs
index ba073b8..599402b 100644
--- a/src/Lucene.Net.Tests/core/Index/TestDocTermOrds.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestDocTermOrds.cs
@@ -353,7 +353,7 @@ namespace Lucene.Net.Index
             {
                 Console.WriteLine("TEST: verify prefix=" + (prefixRef == null ? "null" : prefixRef.Utf8ToString()));
                 Console.WriteLine("TEST: all TERMS:");
-                TermsEnum allTE = MultiFields.GetTerms(r, "field").Iterator(null);
+                TermsEnum allTE = MultiFields.GetTerms(r, "field").GetIterator(null);
                 int ord = 0;
                 while (allTE.Next() != null)
                 {
@@ -374,7 +374,7 @@ namespace Lucene.Net.Index
                     Terms terms = MultiFields.GetTerms(r, "field");
                     if (terms != null)
                     {
-                        TermsEnum termsEnum = terms.Iterator(null);
+                        TermsEnum termsEnum = terms.GetIterator(null);
                         TermsEnum.SeekStatus result = termsEnum.SeekCeil(prefixRef);
                         if (result != TermsEnum.SeekStatus.END)
                         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Index/TestDocsAndPositions.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestDocsAndPositions.cs b/src/Lucene.Net.Tests/core/Index/TestDocsAndPositions.cs
index 1efdf21..03ba737 100644
--- a/src/Lucene.Net.Tests/core/Index/TestDocsAndPositions.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestDocsAndPositions.cs
@@ -105,7 +105,7 @@ namespace Lucene.Net.Index
             Terms terms = reader.Terms(FieldName);
             if (terms != null)
             {
-                TermsEnum te = terms.Iterator(null);
+                TermsEnum te = terms.GetIterator(null);
                 if (te.SeekExact(bytes))
                 {
                     return te.DocsAndPositions(liveDocs, null);
@@ -389,7 +389,7 @@ namespace Lucene.Net.Index
             Assert.IsTrue(disi.NextDoc() != DocIdSetIterator.NO_MORE_DOCS);
 
             // now reuse and check again
-            TermsEnum te = r.Terms("foo").Iterator(null);
+            TermsEnum te = r.Terms("foo").GetIterator(null);
             Assert.IsTrue(te.SeekExact(new BytesRef("bar")));
             disi = TestUtil.Docs(Random(), te, null, disi, DocsEnum.FLAG_NONE);
             docid = disi.DocID;
@@ -416,7 +416,7 @@ namespace Lucene.Net.Index
             Assert.IsTrue(disi.NextDoc() != DocIdSetIterator.NO_MORE_DOCS);
 
             // now reuse and check again
-            TermsEnum te = r.Terms("foo").Iterator(null);
+            TermsEnum te = r.Terms("foo").GetIterator(null);
             Assert.IsTrue(te.SeekExact(new BytesRef("bar")));
             disi = te.DocsAndPositions(null, disi);
             docid = disi.DocID;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Index/TestFilterAtomicReader.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestFilterAtomicReader.cs b/src/Lucene.Net.Tests/core/Index/TestFilterAtomicReader.cs
index 66ec6f2..ff95c85 100644
--- a/src/Lucene.Net.Tests/core/Index/TestFilterAtomicReader.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestFilterAtomicReader.cs
@@ -61,9 +61,9 @@ namespace Lucene.Net.Index
                 {
                 }
 
-                public override TermsEnum Iterator(TermsEnum reuse)
+                public override TermsEnum GetIterator(TermsEnum reuse)
                 {
-                    return new TestTermsEnum(base.Iterator(reuse));
+                    return new TestTermsEnum(base.GetIterator(reuse));
                 }
             }
 
@@ -167,7 +167,7 @@ namespace Lucene.Net.Index
             reader.Dispose();
             reader = DirectoryReader.Open(target);
 
-            TermsEnum terms = MultiFields.GetTerms(reader, "default").Iterator(null);
+            TermsEnum terms = MultiFields.GetTerms(reader, "default").GetIterator(null);
             while (terms.Next() != null)
             {
                 Assert.IsTrue(terms.Term.Utf8ToString().IndexOf('e') != -1);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Index/TestFlex.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestFlex.cs b/src/Lucene.Net.Tests/core/Index/TestFlex.cs
index 30fdf7b..4c6a924 100644
--- a/src/Lucene.Net.Tests/core/Index/TestFlex.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestFlex.cs
@@ -61,7 +61,7 @@ namespace Lucene.Net.Index
 
                 IndexReader r = w.Reader;
 
-                TermsEnum terms = MultiFields.GetTerms(r, "field3").Iterator(null);
+                TermsEnum terms = MultiFields.GetTerms(r, "field3").GetIterator(null);
                 Assert.AreEqual(TermsEnum.SeekStatus.END, terms.SeekCeil(new BytesRef("abc")));
                 r.Dispose();
             }
@@ -80,7 +80,7 @@ namespace Lucene.Net.Index
             w.AddDocument(doc);
             w.ForceMerge(1);
             DirectoryReader r = w.Reader;
-            TermsEnum terms = GetOnlySegmentReader(r).Fields.Terms("f").Iterator(null);
+            TermsEnum terms = GetOnlySegmentReader(r).Fields.Terms("f").GetIterator(null);
             Assert.IsTrue(terms.Next() != null);
             try
             {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Index/TestIndexWriter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestIndexWriter.cs b/src/Lucene.Net.Tests/core/Index/TestIndexWriter.cs
index 5810adf..b2d5535 100644
--- a/src/Lucene.Net.Tests/core/Index/TestIndexWriter.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestIndexWriter.cs
@@ -917,7 +917,7 @@ namespace Lucene.Net.Index
             writer.Dispose();
             DirectoryReader reader = DirectoryReader.Open(dir);
             AtomicReader subreader = GetOnlySegmentReader(reader);
-            TermsEnum te = subreader.Fields.Terms("").Iterator(null);
+            TermsEnum te = subreader.Fields.Terms("").GetIterator(null);
             Assert.AreEqual(new BytesRef("a"), te.Next());
             Assert.AreEqual(new BytesRef("b"), te.Next());
             Assert.AreEqual(new BytesRef("c"), te.Next());
@@ -940,7 +940,7 @@ namespace Lucene.Net.Index
             writer.Dispose();
             DirectoryReader reader = DirectoryReader.Open(dir);
             AtomicReader subreader = GetOnlySegmentReader(reader);
-            TermsEnum te = subreader.Fields.Terms("").Iterator(null);
+            TermsEnum te = subreader.Fields.Terms("").GetIterator(null);
             Assert.AreEqual(new BytesRef(""), te.Next());
             Assert.AreEqual(new BytesRef("a"), te.Next());
             Assert.AreEqual(new BytesRef("b"), te.Next());
@@ -1078,7 +1078,7 @@ namespace Lucene.Net.Index
 
             IndexReader r = DirectoryReader.Open(dir);
             Terms tpv = r.GetTermVectors(0).Terms("field");
-            TermsEnum termsEnum = tpv.Iterator(null);
+            TermsEnum termsEnum = tpv.GetIterator(null);
             Assert.IsNotNull(termsEnum.Next());
             DocsAndPositionsEnum dpEnum = termsEnum.DocsAndPositions(null, null);
             Assert.IsNotNull(dpEnum);
@@ -1582,7 +1582,7 @@ namespace Lucene.Net.Index
             w.AddDocument(d);
 
             AtomicReader r = GetOnlySegmentReader(w.Reader);
-            TermsEnum t = r.Fields.Terms("field").Iterator(null);
+            TermsEnum t = r.Fields.Terms("field").GetIterator(null);
             int count = 0;
             while (t.Next() != null)
             {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Index/TestIndexWriterUnicode.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestIndexWriterUnicode.cs b/src/Lucene.Net.Tests/core/Index/TestIndexWriterUnicode.cs
index 0e4862b..251f05d 100644
--- a/src/Lucene.Net.Tests/core/Index/TestIndexWriterUnicode.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestIndexWriterUnicode.cs
@@ -149,7 +149,7 @@ namespace Lucene.Net.Index
 
         private void CheckTermsOrder(IndexReader r, ISet<string> allTerms, bool isTop)
         {
-            TermsEnum terms = MultiFields.GetFields(r).Terms("f").Iterator(null);
+            TermsEnum terms = MultiFields.GetFields(r).Terms("f").GetIterator(null);
 
             BytesRef last = new BytesRef();
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Index/TestIndexableField.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestIndexableField.cs b/src/Lucene.Net.Tests/core/Index/TestIndexableField.cs
index 68986a0..a3d76b0 100644
--- a/src/Lucene.Net.Tests/core/Index/TestIndexableField.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestIndexableField.cs
@@ -320,7 +320,7 @@ namespace Lucene.Net.Index
                         {
                             Terms tfv = r.GetTermVectors(docID).Terms(name);
                             Assert.IsNotNull(tfv);
-                            TermsEnum termsEnum = tfv.Iterator(null);
+                            TermsEnum termsEnum = tfv.GetIterator(null);
                             Assert.AreEqual(new BytesRef("" + counter), termsEnum.Next());
                             Assert.AreEqual(1, termsEnum.TotalTermFreq);
                             DocsAndPositionsEnum dpEnum = termsEnum.DocsAndPositions(null, null);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Index/TestParallelTermEnum.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestParallelTermEnum.cs b/src/Lucene.Net.Tests/core/Index/TestParallelTermEnum.cs
index f57dc3b..db90e9f 100644
--- a/src/Lucene.Net.Tests/core/Index/TestParallelTermEnum.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestParallelTermEnum.cs
@@ -81,7 +81,7 @@ namespace Lucene.Net.Index
         private void CheckTerms(Terms terms, IBits liveDocs, params string[] termsList)
         {
             Assert.IsNotNull(terms);
-            TermsEnum te = terms.Iterator(null);
+            TermsEnum te = terms.GetIterator(null);
 
             foreach (string t in termsList)
             {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Index/TestPayloads.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestPayloads.cs b/src/Lucene.Net.Tests/core/Index/TestPayloads.cs
index 6278405..e1798f6 100644
--- a/src/Lucene.Net.Tests/core/Index/TestPayloads.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestPayloads.cs
@@ -493,7 +493,7 @@ namespace Lucene.Net.Index
             }
             writer.Dispose();
             IndexReader reader = DirectoryReader.Open(dir);
-            TermsEnum terms = MultiFields.GetFields(reader).Terms(field).Iterator(null);
+            TermsEnum terms = MultiFields.GetFields(reader).Terms(field).GetIterator(null);
             IBits liveDocs = MultiFields.GetLiveDocs(reader);
             DocsAndPositionsEnum tp = null;
             while (terms.Next() != null)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Index/TestPayloadsOnVectors.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestPayloadsOnVectors.cs b/src/Lucene.Net.Tests/core/Index/TestPayloadsOnVectors.cs
index b2dec2a..81d8863 100644
--- a/src/Lucene.Net.Tests/core/Index/TestPayloadsOnVectors.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestPayloadsOnVectors.cs
@@ -79,7 +79,7 @@ namespace Lucene.Net.Index
             DirectoryReader reader = writer.Reader;
             Terms terms = reader.GetTermVector(1, "field");
             Debug.Assert(terms != null);
-            TermsEnum termsEnum = terms.Iterator(null);
+            TermsEnum termsEnum = terms.GetIterator(null);
             Assert.IsTrue(termsEnum.SeekExact(new BytesRef("withPayload")));
             DocsAndPositionsEnum de = termsEnum.DocsAndPositions(null, null);
             Assert.AreEqual(0, de.NextDoc());
@@ -124,7 +124,7 @@ namespace Lucene.Net.Index
             DirectoryReader reader = writer.Reader;
             Terms terms = reader.GetTermVector(0, "field");
             Debug.Assert(terms != null);
-            TermsEnum termsEnum = terms.Iterator(null);
+            TermsEnum termsEnum = terms.GetIterator(null);
             Assert.IsTrue(termsEnum.SeekExact(new BytesRef("withPayload")));
             DocsAndPositionsEnum de = termsEnum.DocsAndPositions(null, null);
             Assert.AreEqual(0, de.NextDoc());

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Index/TestPerSegmentDeletes.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestPerSegmentDeletes.cs b/src/Lucene.Net.Tests/core/Index/TestPerSegmentDeletes.cs
index 6ac74af..a665696 100644
--- a/src/Lucene.Net.Tests/core/Index/TestPerSegmentDeletes.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestPerSegmentDeletes.cs
@@ -246,7 +246,7 @@ namespace Lucene.Net.Index
         {
             Fields fields = MultiFields.GetFields(reader);
             Terms cterms = fields.Terms(term.Field);
-            TermsEnum ctermsEnum = cterms.Iterator(null);
+            TermsEnum ctermsEnum = cterms.GetIterator(null);
             if (ctermsEnum.SeekExact(new BytesRef(term.Text())))
             {
                 DocsEnum docsEnum = TestUtil.Docs(Random(), ctermsEnum, bits, null, DocsEnum.FLAG_NONE);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Index/TestPostingsOffsets.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestPostingsOffsets.cs b/src/Lucene.Net.Tests/core/Index/TestPostingsOffsets.cs
index edf670c..f09a50c 100644
--- a/src/Lucene.Net.Tests/core/Index/TestPostingsOffsets.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestPostingsOffsets.cs
@@ -327,7 +327,7 @@ namespace Lucene.Net.Index
                 // TODO: improve this
                 AtomicReader sub = (AtomicReader)ctx.Reader;
                 //System.out.println("\nsub=" + sub);
-                TermsEnum termsEnum = sub.Fields.Terms("content").Iterator(null);
+                TermsEnum termsEnum = sub.Fields.Terms("content").GetIterator(null);
                 DocsEnum docs = null;
                 DocsAndPositionsEnum docsAndPositions = null;
                 DocsAndPositionsEnum docsAndPositionsAndOffsets = null;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Index/TestSegmentMerger.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestSegmentMerger.cs b/src/Lucene.Net.Tests/core/Index/TestSegmentMerger.cs
index 0cd5a7d..f73c270 100644
--- a/src/Lucene.Net.Tests/core/Index/TestSegmentMerger.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestSegmentMerger.cs
@@ -131,7 +131,7 @@ namespace Lucene.Net.Index
             Terms vector = mergedReader.GetTermVectors(0).Terms(DocHelper.TEXT_FIELD_2_KEY);
             Assert.IsNotNull(vector);
             Assert.AreEqual(3, vector.Count);
-            TermsEnum termsEnum = vector.Iterator(null);
+            TermsEnum termsEnum = vector.GetIterator(null);
 
             int i = 0;
             while (termsEnum.Next() != null)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Index/TestSegmentReader.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestSegmentReader.cs b/src/Lucene.Net.Tests/core/Index/TestSegmentReader.cs
index 5820321..effcd5c 100644
--- a/src/Lucene.Net.Tests/core/Index/TestSegmentReader.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestSegmentReader.cs
@@ -142,7 +142,7 @@ namespace Lucene.Net.Index
             {
                 Terms terms = fields.Terms(field);
                 Assert.IsNotNull(terms);
-                TermsEnum termsEnum = terms.Iterator(null);
+                TermsEnum termsEnum = terms.GetIterator(null);
                 while (termsEnum.Next() != null)
                 {
                     BytesRef term = termsEnum.Term;
@@ -211,7 +211,7 @@ namespace Lucene.Net.Index
             Terms result = Reader.GetTermVectors(0).Terms(DocHelper.TEXT_FIELD_2_KEY);
             Assert.IsNotNull(result);
             Assert.AreEqual(3, result.Count);
-            TermsEnum termsEnum = result.Iterator(null);
+            TermsEnum termsEnum = result.GetIterator(null);
             while (termsEnum.Next() != null)
             {
                 string term = termsEnum.Term.Utf8ToString();

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Index/TestSegmentTermDocs.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestSegmentTermDocs.cs b/src/Lucene.Net.Tests/core/Index/TestSegmentTermDocs.cs
index ad07a66..dc8d8a9 100644
--- a/src/Lucene.Net.Tests/core/Index/TestSegmentTermDocs.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestSegmentTermDocs.cs
@@ -73,7 +73,7 @@ namespace Lucene.Net.Index
             Assert.IsTrue(reader != null);
             Assert.AreEqual(indexDivisor, reader.TermInfosIndexDivisor);
 
-            TermsEnum terms = reader.Fields.Terms(DocHelper.TEXT_FIELD_2_KEY).Iterator(null);
+            TermsEnum terms = reader.Fields.Terms(DocHelper.TEXT_FIELD_2_KEY).GetIterator(null);
             terms.SeekCeil(new BytesRef("field"));
             DocsEnum termDocs = TestUtil.Docs(Random(), terms, reader.LiveDocs, null, DocsEnum.FLAG_FREQS);
             if (termDocs.NextDoc() != DocIdSetIterator.NO_MORE_DOCS)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Index/TestSegmentTermEnum.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestSegmentTermEnum.cs b/src/Lucene.Net.Tests/core/Index/TestSegmentTermEnum.cs
index e43bc9b..e6bdca3 100644
--- a/src/Lucene.Net.Tests/core/Index/TestSegmentTermEnum.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestSegmentTermEnum.cs
@@ -86,7 +86,7 @@ namespace Lucene.Net.Index
             AddDoc(writer, "aaa bbb");
             writer.Dispose();
             SegmentReader reader = GetOnlySegmentReader(DirectoryReader.Open(Dir));
-            TermsEnum terms = reader.Fields.Terms("content").Iterator(null);
+            TermsEnum terms = reader.Fields.Terms("content").GetIterator(null);
             Assert.IsNotNull(terms.Next());
             Assert.AreEqual("aaa", terms.Term.Utf8ToString());
             Assert.IsNotNull(terms.Next());
@@ -114,7 +114,7 @@ namespace Lucene.Net.Index
         private void VerifyDocFreq()
         {
             IndexReader reader = DirectoryReader.Open(Dir);
-            TermsEnum termEnum = MultiFields.GetTerms(reader, "content").Iterator(null);
+            TermsEnum termEnum = MultiFields.GetTerms(reader, "content").GetIterator(null);
 
             // create enumeration of all terms
             // go to the first term (aaa)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Index/TestStressAdvance.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestStressAdvance.cs b/src/Lucene.Net.Tests/core/Index/TestStressAdvance.cs
index 9215dc8..aeefc90 100644
--- a/src/Lucene.Net.Tests/core/Index/TestStressAdvance.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestStressAdvance.cs
@@ -91,7 +91,7 @@ namespace Lucene.Net.Index
                         bDocIDs.Add(docID);
                     }
                 }
-                TermsEnum te = GetOnlySegmentReader(r).Fields.Terms("field").Iterator(null);
+                TermsEnum te = GetOnlySegmentReader(r).Fields.Terms("field").GetIterator(null);
 
                 DocsEnum de = null;
                 for (int iter2 = 0; iter2 < 10; iter2++)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Index/TestStressIndexing2.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestStressIndexing2.cs b/src/Lucene.Net.Tests/core/Index/TestStressIndexing2.cs
index 77d6e8f..489c913 100644
--- a/src/Lucene.Net.Tests/core/Index/TestStressIndexing2.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestStressIndexing2.cs
@@ -372,7 +372,7 @@ namespace Lucene.Net.Index
                 Assert.IsTrue(MultiFields.GetFields(r2) == null || MultiFields.GetFields(r2).Terms(idField) == null);
                 return;
             }
-            TermsEnum termsEnum = terms1.Iterator(null);
+            TermsEnum termsEnum = terms1.GetIterator(null);
 
             IBits liveDocs1 = MultiFields.GetLiveDocs(r1);
             IBits liveDocs2 = MultiFields.GetLiveDocs(r2);
@@ -395,7 +395,7 @@ namespace Lucene.Net.Index
                 return;
             }
             Terms terms2 = fields.Terms(idField);
-            TermsEnum termsEnum2 = terms2.Iterator(null);
+            TermsEnum termsEnum2 = terms2.GetIterator(null);
 
             DocsEnum termDocs1 = null;
             DocsEnum termDocs2 = null;
@@ -467,7 +467,7 @@ namespace Lucene.Net.Index
                             Console.WriteLine("    " + field + ":");
                             Terms terms3 = tv1.Terms(field);
                             Assert.IsNotNull(terms3);
-                            TermsEnum termsEnum3 = terms3.Iterator(null);
+                            TermsEnum termsEnum3 = terms3.GetIterator(null);
                             BytesRef term2;
                             while ((term2 = termsEnum3.Next()) != null)
                             {
@@ -506,7 +506,7 @@ namespace Lucene.Net.Index
                             Console.WriteLine("    " + field + ":");
                             Terms terms3 = tv2.Terms(field);
                             Assert.IsNotNull(terms3);
-                            TermsEnum termsEnum3 = terms3.Iterator(null);
+                            TermsEnum termsEnum3 = terms3.GetIterator(null);
                             BytesRef term2;
                             while ((term2 = termsEnum3.Next()) != null)
                             {
@@ -577,7 +577,7 @@ namespace Lucene.Net.Index
                         {
                             continue;
                         }
-                        termsEnum1 = terms.Iterator(null);
+                        termsEnum1 = terms.GetIterator(null);
                     }
                     term1 = termsEnum1.Next();
                     if (term1 == null)
@@ -619,7 +619,7 @@ namespace Lucene.Net.Index
                         {
                             continue;
                         }
-                        termsEnum2 = terms.Iterator(null);
+                        termsEnum2 = terms.GetIterator(null);
                     }
                     term2 = termsEnum2.Next();
                     if (term2 == null)
@@ -717,11 +717,11 @@ namespace Lucene.Net.Index
 
                 Terms terms1 = d1.Terms(field1);
                 Assert.IsNotNull(terms1);
-                TermsEnum termsEnum1 = terms1.Iterator(null);
+                TermsEnum termsEnum1 = terms1.GetIterator(null);
 
                 Terms terms2 = d2.Terms(field2);
                 Assert.IsNotNull(terms2);
-                TermsEnum termsEnum2 = terms2.Iterator(null);
+                TermsEnum termsEnum2 = terms2.GetIterator(null);
 
                 DocsAndPositionsEnum dpEnum1 = null;
                 DocsAndPositionsEnum dpEnum2 = null;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Index/TestSumDocFreq.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestSumDocFreq.cs b/src/Lucene.Net.Tests/core/Index/TestSumDocFreq.cs
index 63b07e6..c18ef01 100644
--- a/src/Lucene.Net.Tests/core/Index/TestSumDocFreq.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestSumDocFreq.cs
@@ -100,7 +100,7 @@ namespace Lucene.Net.Index
                 }
 
                 long computedSumDocFreq = 0;
-                TermsEnum termsEnum = terms.Iterator(null);
+                TermsEnum termsEnum = terms.GetIterator(null);
                 while (termsEnum.Next() != null)
                 {
                     computedSumDocFreq += termsEnum.DocFreq;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Index/TestTermVectorsReader.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestTermVectorsReader.cs b/src/Lucene.Net.Tests/core/Index/TestTermVectorsReader.cs
index cb39326..694005c 100644
--- a/src/Lucene.Net.Tests/core/Index/TestTermVectorsReader.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestTermVectorsReader.cs
@@ -250,7 +250,7 @@ namespace Lucene.Net.Index
                 Terms vector = reader.Get(j).Terms(TestFields[0]);
                 Assert.IsNotNull(vector);
                 Assert.AreEqual(TestTerms.Length, vector.Count);
-                TermsEnum termsEnum = vector.Iterator(null);
+                TermsEnum termsEnum = vector.GetIterator(null);
                 for (int i = 0; i < TestTerms.Length; i++)
                 {
                     BytesRef text = termsEnum.Next();
@@ -273,7 +273,7 @@ namespace Lucene.Net.Index
                 Terms vector = reader.Get(j).Terms(TestFields[0]);
                 Assert.IsNotNull(vector);
                 Assert.AreEqual(TestTerms.Length, vector.Count);
-                TermsEnum termsEnum = vector.Iterator(null);
+                TermsEnum termsEnum = vector.GetIterator(null);
                 DocsEnum docsEnum = null;
                 for (int i = 0; i < TestTerms.Length; i++)
                 {
@@ -303,7 +303,7 @@ namespace Lucene.Net.Index
             Terms vector = reader.Get(0).Terms(TestFields[0]);
             Assert.IsNotNull(vector);
             Assert.AreEqual(TestTerms.Length, vector.Count);
-            TermsEnum termsEnum = vector.Iterator(null);
+            TermsEnum termsEnum = vector.GetIterator(null);
             DocsAndPositionsEnum dpEnum = null;
             for (int i = 0; i < TestTerms.Length; i++)
             {
@@ -343,7 +343,7 @@ namespace Lucene.Net.Index
             Terms freqVector = reader.Get(0).Terms(TestFields[1]); //no pos, no offset
             Assert.IsNotNull(freqVector);
             Assert.AreEqual(TestTerms.Length, freqVector.Count);
-            termsEnum = freqVector.Iterator(null);
+            termsEnum = freqVector.GetIterator(null);
             Assert.IsNotNull(termsEnum);
             for (int i = 0; i < TestTerms.Length; i++)
             {
@@ -364,7 +364,7 @@ namespace Lucene.Net.Index
             TermVectorsReader reader = Codec.Default.TermVectorsFormat.VectorsReader(Dir, Seg.Info, FieldInfos, NewIOContext(Random()));
             Terms vector = reader.Get(0).Terms(TestFields[0]);
             Assert.IsNotNull(vector);
-            TermsEnum termsEnum = vector.Iterator(null);
+            TermsEnum termsEnum = vector.GetIterator(null);
             Assert.IsNotNull(termsEnum);
             Assert.AreEqual(TestTerms.Length, vector.Count);
             DocsAndPositionsEnum dpEnum = null;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Index/TestTermVectorsWriter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestTermVectorsWriter.cs b/src/Lucene.Net.Tests/core/Index/TestTermVectorsWriter.cs
index 0f653b0..9cd1989 100644
--- a/src/Lucene.Net.Tests/core/Index/TestTermVectorsWriter.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestTermVectorsWriter.cs
@@ -69,7 +69,7 @@ namespace Lucene.Net.Index
             IndexReader r = DirectoryReader.Open(dir);
             Terms vector = r.GetTermVectors(0).Terms("field");
             Assert.IsNotNull(vector);
-            TermsEnum termsEnum = vector.Iterator(null);
+            TermsEnum termsEnum = vector.GetIterator(null);
             Assert.IsNotNull(termsEnum.Next());
             Assert.AreEqual("", termsEnum.Term.Utf8ToString());
 
@@ -125,7 +125,7 @@ namespace Lucene.Net.Index
             w.Dispose();
 
             IndexReader r = DirectoryReader.Open(dir);
-            TermsEnum termsEnum = r.GetTermVectors(0).Terms("field").Iterator(null);
+            TermsEnum termsEnum = r.GetTermVectors(0).Terms("field").GetIterator(null);
             Assert.IsNotNull(termsEnum.Next());
             DocsAndPositionsEnum dpEnum = termsEnum.DocsAndPositions(null, null);
             Assert.AreEqual(2, termsEnum.TotalTermFreq);
@@ -162,7 +162,7 @@ namespace Lucene.Net.Index
             w.Dispose();
 
             IndexReader r = DirectoryReader.Open(dir);
-            TermsEnum termsEnum = r.GetTermVectors(0).Terms("field").Iterator(null);
+            TermsEnum termsEnum = r.GetTermVectors(0).Terms("field").GetIterator(null);
             Assert.IsNotNull(termsEnum.Next());
             DocsAndPositionsEnum dpEnum = termsEnum.DocsAndPositions(null, null);
             Assert.AreEqual(2, termsEnum.TotalTermFreq);
@@ -215,7 +215,7 @@ namespace Lucene.Net.Index
             w.Dispose();
 
             IndexReader r = DirectoryReader.Open(dir);
-            TermsEnum termsEnum = r.GetTermVectors(0).Terms("field").Iterator(null);
+            TermsEnum termsEnum = r.GetTermVectors(0).Terms("field").GetIterator(null);
             Assert.IsNotNull(termsEnum.Next());
             DocsAndPositionsEnum dpEnum = termsEnum.DocsAndPositions(null, null);
             Assert.AreEqual(2, termsEnum.TotalTermFreq);
@@ -252,7 +252,7 @@ namespace Lucene.Net.Index
             w.Dispose();
 
             IndexReader r = DirectoryReader.Open(dir);
-            TermsEnum termsEnum = r.GetTermVectors(0).Terms("field").Iterator(null);
+            TermsEnum termsEnum = r.GetTermVectors(0).Terms("field").GetIterator(null);
             Assert.IsNotNull(termsEnum.Next());
             DocsAndPositionsEnum dpEnum = termsEnum.DocsAndPositions(null, null);
             Assert.AreEqual(2, termsEnum.TotalTermFreq);
@@ -290,7 +290,7 @@ namespace Lucene.Net.Index
             w.Dispose();
 
             IndexReader r = DirectoryReader.Open(dir);
-            TermsEnum termsEnum = r.GetTermVectors(0).Terms("field").Iterator(null);
+            TermsEnum termsEnum = r.GetTermVectors(0).Terms("field").GetIterator(null);
             Assert.IsNotNull(termsEnum.Next());
             DocsAndPositionsEnum dpEnum = termsEnum.DocsAndPositions(null, null);
 
@@ -336,7 +336,7 @@ namespace Lucene.Net.Index
             w.Dispose();
 
             IndexReader r = DirectoryReader.Open(dir);
-            TermsEnum termsEnum = r.GetTermVectors(0).Terms("field").Iterator(null);
+            TermsEnum termsEnum = r.GetTermVectors(0).Terms("field").GetIterator(null);
             Assert.IsNotNull(termsEnum.Next());
             DocsAndPositionsEnum dpEnum = termsEnum.DocsAndPositions(null, null);
 
@@ -380,7 +380,7 @@ namespace Lucene.Net.Index
             w.Dispose();
 
             IndexReader r = DirectoryReader.Open(dir);
-            TermsEnum termsEnum = r.GetTermVectors(0).Terms("field").Iterator(null);
+            TermsEnum termsEnum = r.GetTermVectors(0).Terms("field").GetIterator(null);
             Assert.IsNotNull(termsEnum.Next());
             DocsAndPositionsEnum dpEnum = termsEnum.DocsAndPositions(null, null);
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Index/TestTermdocPerf.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestTermdocPerf.cs b/src/Lucene.Net.Tests/core/Index/TestTermdocPerf.cs
index 34fbfca..c76b4ee 100644
--- a/src/Lucene.Net.Tests/core/Index/TestTermdocPerf.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestTermdocPerf.cs
@@ -136,7 +136,7 @@ namespace Lucene.Net.Index
 
             IndexReader reader = DirectoryReader.Open(dir);
 
-            TermsEnum tenum = MultiFields.GetTerms(reader, "foo").Iterator(null);
+            TermsEnum tenum = MultiFields.GetTerms(reader, "foo").GetIterator(null);
 
             start = Environment.TickCount;
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Index/TestTermsEnum.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestTermsEnum.cs b/src/Lucene.Net.Tests/core/Index/TestTermsEnum.cs
index cdb7a40..608fee0 100644
--- a/src/Lucene.Net.Tests/core/Index/TestTermsEnum.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestTermsEnum.cs
@@ -64,7 +64,7 @@ namespace Lucene.Net.Index
             w.Dispose();
 
             List<BytesRef> terms = new List<BytesRef>();
-            TermsEnum termsEnum = MultiFields.GetTerms(r, "body").Iterator(null);
+            TermsEnum termsEnum = MultiFields.GetTerms(r, "body").GetIterator(null);
             BytesRef term;
             while ((term = termsEnum.Next()) != null)
             {
@@ -568,7 +568,7 @@ namespace Lucene.Net.Index
                 Assert.AreEqual(1, DocFreq(r, "xx"));
                 Assert.AreEqual(1, DocFreq(r, "aa4"));
 
-                TermsEnum te = MultiFields.GetTerms(r, FIELD).Iterator(null);
+                TermsEnum te = MultiFields.GetTerms(r, FIELD).GetIterator(null);
                 while (te.Next() != null)
                 {
                     //System.out.println("TEST: next term=" + te.Term().Utf8ToString());
@@ -604,7 +604,7 @@ namespace Lucene.Net.Index
             Terms terms = MultiFields.GetTerms(r, "field");
             if (terms != null)
             {
-                Assert.IsNull(terms.Iterator(null).Next());
+                Assert.IsNull(terms.GetIterator(null).Next());
             }
             r.Dispose();
             d.Dispose();
@@ -737,7 +737,7 @@ namespace Lucene.Net.Index
                     Console.WriteLine("  " + t.Utf8ToString() + " " + t);
                 }
             }
-            TermsEnum te = MultiFields.GetTerms(r, FIELD).Iterator(null);
+            TermsEnum te = MultiFields.GetTerms(r, FIELD).GetIterator(null);
 
             int END_LOC = -validTerms.Length - 1;
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Index/TestTermsEnum2.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestTermsEnum2.cs b/src/Lucene.Net.Tests/core/Index/TestTermsEnum2.cs
index eaad20c..d6cdaf8 100644
--- a/src/Lucene.Net.Tests/core/Index/TestTermsEnum2.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestTermsEnum2.cs
@@ -124,7 +124,7 @@ namespace Lucene.Net.Index
             {
                 string reg = AutomatonTestUtil.RandomRegexp(Random());
                 Automaton automaton = (new RegExp(reg, RegExp.NONE)).ToAutomaton();
-                TermsEnum te = MultiFields.GetTerms(Reader, "field").Iterator(null);
+                TermsEnum te = MultiFields.GetTerms(Reader, "field").GetIterator(null);
                 IList<BytesRef> unsortedTerms = new List<BytesRef>(Terms);
                 unsortedTerms = CollectionsHelper.Shuffle(unsortedTerms);
 
@@ -156,7 +156,7 @@ namespace Lucene.Net.Index
         {
             for (int i = 0; i < NumIterations; i++)
             {
-                TermsEnum te = MultiFields.GetTerms(Reader, "field").Iterator(null);
+                TermsEnum te = MultiFields.GetTerms(Reader, "field").GetIterator(null);
 
                 foreach (BytesRef term in Terms)
                 {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Search/TestMultiPhraseQuery.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Search/TestMultiPhraseQuery.cs b/src/Lucene.Net.Tests/core/Search/TestMultiPhraseQuery.cs
index 8b2f669..a27562a 100644
--- a/src/Lucene.Net.Tests/core/Search/TestMultiPhraseQuery.cs
+++ b/src/Lucene.Net.Tests/core/Search/TestMultiPhraseQuery.cs
@@ -78,7 +78,7 @@ namespace Lucene.Net.Search
 
             // this TermEnum gives "piccadilly", "pie" and "pizza".
             string prefix = "pi";
-            TermsEnum te = MultiFields.GetFields(reader).Terms("body").Iterator(null);
+            TermsEnum te = MultiFields.GetFields(reader).Terms("body").GetIterator(null);
             te.SeekCeil(new BytesRef(prefix));
             do
             {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Search/TestMultiTermQueryRewrites.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Search/TestMultiTermQueryRewrites.cs b/src/Lucene.Net.Tests/core/Search/TestMultiTermQueryRewrites.cs
index d4d5e1d..fd04407 100644
--- a/src/Lucene.Net.Tests/core/Search/TestMultiTermQueryRewrites.cs
+++ b/src/Lucene.Net.Tests/core/Search/TestMultiTermQueryRewrites.cs
@@ -212,7 +212,7 @@ namespace Lucene.Net.Search
 
             protected override TermsEnum GetTermsEnum(Terms terms, AttributeSource atts)
             {
-                return new TermRangeTermsEnumAnonymousInnerClassHelper(this, terms.Iterator(null), new BytesRef("2"), new BytesRef("7"));
+                return new TermRangeTermsEnumAnonymousInnerClassHelper(this, terms.GetIterator(null), new BytesRef("2"), new BytesRef("7"));
             }
 
             private class TermRangeTermsEnumAnonymousInnerClassHelper : TermRangeTermsEnum

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Search/TestMultiThreadTermVectors.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Search/TestMultiThreadTermVectors.cs b/src/Lucene.Net.Tests/core/Search/TestMultiThreadTermVectors.cs
index 03b42b5..501a84c 100644
--- a/src/Lucene.Net.Tests/core/Search/TestMultiThreadTermVectors.cs
+++ b/src/Lucene.Net.Tests/core/Search/TestMultiThreadTermVectors.cs
@@ -214,7 +214,7 @@ namespace Lucene.Net.Search
                 Terms vector = Reader.GetTermVectors(docId).Terms("field");
                 TimeElapsed += Environment.TickCount - start;
 
-                VerifyVector(vector.Iterator(null), docId);
+                VerifyVector(vector.GetIterator(null), docId);
             }
         }
 
@@ -224,7 +224,7 @@ namespace Lucene.Net.Search
             {
                 Terms terms = vectors.Terms(field);
                 Debug.Assert(terms != null);
-                VerifyVector(terms.Iterator(null), num);
+                VerifyVector(terms.GetIterator(null), num);
             }
         }
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Search/TestPhrasePrefixQuery.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Search/TestPhrasePrefixQuery.cs b/src/Lucene.Net.Tests/core/Search/TestPhrasePrefixQuery.cs
index 00ac1d8..9a0864e 100644
--- a/src/Lucene.Net.Tests/core/Search/TestPhrasePrefixQuery.cs
+++ b/src/Lucene.Net.Tests/core/Search/TestPhrasePrefixQuery.cs
@@ -77,7 +77,7 @@ namespace Lucene.Net.Search
 
             // this TermEnum gives "piccadilly", "pie" and "pizza".
             string prefix = "pi";
-            TermsEnum te = MultiFields.GetFields(reader).Terms("body").Iterator(null);
+            TermsEnum te = MultiFields.GetFields(reader).Terms("body").GetIterator(null);
             te.SeekCeil(new BytesRef(prefix));
             do
             {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Search/TestPrefixRandom.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Search/TestPrefixRandom.cs b/src/Lucene.Net.Tests/core/Search/TestPrefixRandom.cs
index b78aa41..0eb2314 100644
--- a/src/Lucene.Net.Tests/core/Search/TestPrefixRandom.cs
+++ b/src/Lucene.Net.Tests/core/Search/TestPrefixRandom.cs
@@ -100,7 +100,7 @@ namespace Lucene.Net.Search
 
             protected override TermsEnum GetTermsEnum(Terms terms, AttributeSource atts)
             {
-                return new SimplePrefixTermsEnum(this, terms.Iterator(null), Prefix);
+                return new SimplePrefixTermsEnum(this, terms.GetIterator(null), Prefix);
             }
 
             private class SimplePrefixTermsEnum : FilteredTermsEnum

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Search/TestRegexpRandom2.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Search/TestRegexpRandom2.cs b/src/Lucene.Net.Tests/core/Search/TestRegexpRandom2.cs
index ba29511..434e75c 100644
--- a/src/Lucene.Net.Tests/core/Search/TestRegexpRandom2.cs
+++ b/src/Lucene.Net.Tests/core/Search/TestRegexpRandom2.cs
@@ -120,7 +120,7 @@ namespace Lucene.Net.Search
 
             protected override TermsEnum GetTermsEnum(Terms terms, AttributeSource atts)
             {
-                return new SimpleAutomatonTermsEnum(this, terms.Iterator(null));
+                return new SimpleAutomatonTermsEnum(this, terms.GetIterator(null));
             }
 
             private sealed class SimpleAutomatonTermsEnum : FilteredTermsEnum

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Search/TestSameScoresWithThreads.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Search/TestSameScoresWithThreads.cs b/src/Lucene.Net.Tests/core/Search/TestSameScoresWithThreads.cs
index 31b615d..7179b51 100644
--- a/src/Lucene.Net.Tests/core/Search/TestSameScoresWithThreads.cs
+++ b/src/Lucene.Net.Tests/core/Search/TestSameScoresWithThreads.cs
@@ -67,7 +67,7 @@ namespace Lucene.Net.Search
             IndexSearcher s = NewSearcher(r);
             Terms terms = MultiFields.GetFields(r).Terms("body");
             int termCount = 0;
-            TermsEnum termsEnum = terms.Iterator(null);
+            TermsEnum termsEnum = terms.GetIterator(null);
             while (termsEnum.Next() != null)
             {
                 termCount++;
@@ -76,7 +76,7 @@ namespace Lucene.Net.Search
 
             // Target ~10 terms to search:
             double chance = 10.0 / termCount;
-            termsEnum = terms.Iterator(termsEnum);
+            termsEnum = terms.GetIterator(termsEnum);
             IDictionary<BytesRef, TopDocs> answers = new Dictionary<BytesRef, TopDocs>();
             while (termsEnum.Next() != null)
             {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Search/TestShardSearching.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Search/TestShardSearching.cs b/src/Lucene.Net.Tests/core/Search/TestShardSearching.cs
index 6b0db71..2626873 100644
--- a/src/Lucene.Net.Tests/core/Search/TestShardSearching.cs
+++ b/src/Lucene.Net.Tests/core/Search/TestShardSearching.cs
@@ -198,7 +198,7 @@ namespace Lucene.Net.Search
                         {
                             // TODO: try to "focus" on high freq terms sometimes too
                             // TODO: maybe also periodically reset the terms...?
-                            TermsEnum termsEnum = MultiFields.GetTerms(mockReader, "body").Iterator(null);
+                            TermsEnum termsEnum = MultiFields.GetTerms(mockReader, "body").GetIterator(null);
                             terms = new List<BytesRef>();
                             while (termsEnum.Next() != null)
                             {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Search/TestSort.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Search/TestSort.cs b/src/Lucene.Net.Tests/core/Search/TestSort.cs
index e8b076c..c4205cf 100644
--- a/src/Lucene.Net.Tests/core/Search/TestSort.cs
+++ b/src/Lucene.Net.Tests/core/Search/TestSort.cs
@@ -1563,7 +1563,7 @@ namespace Lucene.Net.Search
 
             public TermsEnum TermsEnum(Terms terms)
             {
-                return terms.Iterator(null);
+                return terms.GetIterator(null);
             }
         }
 
@@ -1621,7 +1621,7 @@ namespace Lucene.Net.Search
 
             public TermsEnum TermsEnum(Terms terms)
             {
-                return terms.Iterator(null);
+                return terms.GetIterator(null);
             }
         }
 
@@ -1679,7 +1679,7 @@ namespace Lucene.Net.Search
 
             public TermsEnum TermsEnum(Terms terms)
             {
-                return terms.Iterator(null);
+                return terms.GetIterator(null);
             }
         }
 
@@ -1737,7 +1737,7 @@ namespace Lucene.Net.Search
 
             public TermsEnum TermsEnum(Terms terms)
             {
-                return terms.Iterator(null);
+                return terms.GetIterator(null);
             }
         }
 
@@ -1795,7 +1795,7 @@ namespace Lucene.Net.Search
 
             public TermsEnum TermsEnum(Terms terms)
             {
-                return terms.Iterator(null);
+                return terms.GetIterator(null);
             }
         }
 
@@ -1853,7 +1853,7 @@ namespace Lucene.Net.Search
 
             public TermsEnum TermsEnum(Terms terms)
             {
-                return terms.Iterator(null);
+                return terms.GetIterator(null);
             }
         }
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Search/TestTermVectors.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Search/TestTermVectors.cs b/src/Lucene.Net.Tests/core/Search/TestTermVectors.cs
index 216e83b..db970a0 100644
--- a/src/Lucene.Net.Tests/core/Search/TestTermVectors.cs
+++ b/src/Lucene.Net.Tests/core/Search/TestTermVectors.cs
@@ -147,7 +147,7 @@ namespace Lucene.Net.Search
             Terms vector = vectors.Terms("field");
             Assert.IsNotNull(vector);
             Assert.AreEqual(1, vector.Count);
-            TermsEnum termsEnum = vector.Iterator(null);
+            TermsEnum termsEnum = vector.GetIterator(null);
             Assert.IsNotNull(termsEnum.Next());
             Assert.AreEqual("one", termsEnum.Term.Utf8ToString());
             Assert.AreEqual(5, termsEnum.TotalTermFreq);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/715372a1/src/Lucene.Net.Tests/core/Util/Fst/TestFSTs.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Util/Fst/TestFSTs.cs b/src/Lucene.Net.Tests/core/Util/Fst/TestFSTs.cs
index 2e36a9c..6eca4d9 100644
--- a/src/Lucene.Net.Tests/core/Util/Fst/TestFSTs.cs
+++ b/src/Lucene.Net.Tests/core/Util/Fst/TestFSTs.cs
@@ -368,7 +368,7 @@ namespace Lucene.Net.Util.Fst
             if (terms != null)
             {
                 IntsRef scratchIntsRef = new IntsRef();
-                TermsEnum termsEnum = terms.Iterator(null);
+                TermsEnum termsEnum = terms.GetIterator(null);
                 if (VERBOSE)
                 {
                     Console.WriteLine("TEST: got termsEnum=" + termsEnum);
@@ -1108,7 +1108,7 @@ namespace Lucene.Net.Util.Fst
                 }
 
                 // Verify w/ MultiTermsEnum
-                TermsEnum termsEnum = MultiFields.GetTerms(r, "id").Iterator(null);
+                TermsEnum termsEnum = MultiFields.GetTerms(r, "id").GetIterator(null);
                 for (int iter = 0; iter < 2 * NUM_IDS; iter++)
                 {
                     string id;


Mime
View raw message