internal SegmentMergeInfo(int b, TermEnum te, IndexReader r)
		{
			base_Renamed = b;
			reader = r;
			termEnum = te;
			term = te.Term;
		}

		public virtual void  Seek(TermEnum termEnum)
		{
			TermInfo ti;
			
			// use comparison of fieldinfos to verify that termEnum belongs to the same segment as this SegmentTermDocs
			if (termEnum is SegmentTermEnum && ((SegmentTermEnum) termEnum).fieldInfos == parent.fieldInfos)
			// optimized case
				ti = ((SegmentTermEnum) termEnum).TermInfo();
			// punt case
			else
				ti = parent.tis.Get(termEnum.Term());
			
			Seek(ti);
		}

		public virtual void  Seek(TermEnum termEnum)
		{
			TermInfo ti;
			Term term;
			
			// use comparison of fieldinfos to verify that termEnum belongs to the same segment as this SegmentTermDocs
			if (termEnum is SegmentTermEnum && ((SegmentTermEnum) termEnum).fieldInfos == parent.core.fieldInfos)
			{
				// optimized case
				var segmentTermEnum = ((SegmentTermEnum) termEnum);
				term = segmentTermEnum.Term;
				ti = segmentTermEnum.TermInfo();
			}
			else
			{
				// punt case
				term = termEnum.Term;
				ti = parent.core.GetTermsReader().Get(term);
			}
			
			Seek(ti, term);
		}

			public FilterTermEnum(TermEnum in_Renamed)
			{
				this.in_Renamed = in_Renamed;
			}

        private static void IndexDirectory(IndexWriter writer, TermEnum uidIter, DirectoryInfo dir, Operation operation) {
            var entries = Directory.GetFileSystemEntries(dir.FullName);

            // Sort the entries. This is important, the uidIter TermEnum is
            // iterated in a forward-only fashion, requiring all files to be
            // passed in ascending order.
            Array.Sort(entries);

            foreach (var entry in entries) {
                var path = Path.Combine(dir.FullName, entry);
                if (Directory.Exists(path)) {
                    IndexDirectory(writer, uidIter, new DirectoryInfo(path), operation);
                } else if (File.Exists(path)) {
                    IndexFile(writer, uidIter, new FileInfo(path), operation);
                }
            }
        }

			public ParallelTermEnum(ParallelReader enclosingInstance)
			{
				InitBlock(enclosingInstance);
				try
				{
					field = ((System.String) Enclosing_Instance.fieldToReader.GetKey(0));
				}
				catch (ArgumentOutOfRangeException e)
				{
					// No fields, so keep field == null, termEnum == null
					return;
				}
				if (field != null)
					termEnum = ((IndexReader) Enclosing_Instance.fieldToReader[field]).Terms();
			}

			public ParallelTermEnum(ParallelReader enclosingInstance, Term term)
			{
				InitBlock(enclosingInstance);
				field = term.Field();
				termEnum = ((IndexReader) Enclosing_Instance.fieldToReader[field]).Terms(term);
			}

 public ParallelTermEnum(ParallelReader enclosingInstance)
 {
     InitBlock(enclosingInstance);
     IEnumerator<string> e = Enclosing_Instance.fieldToReader.Keys.GetEnumerator();
     if (e.MoveNext())
     {
         field = e.Current;
         if (field != null)
             termEnum = Enclosing_Instance.fieldToReader[field].Terms();
     }
 }

			public virtual void  Seek(TermEnum termEnum)
			{
				in_Renamed.Seek(termEnum);
			}

				public TestTermEnum(TermEnum termEnum):base(termEnum)
				{
				}

			public virtual void  Seek(TermEnum termEnum)
			{
				Seek(termEnum.Term());
				if (termEnum is MultiTermEnum)
				{
					tenum = (MultiTermEnum) termEnum;
					if (topReader != tenum.topReader)
						tenum = null;
				}
			}

 /// <summary> Not implemented.</summary>
 /// <throws>  UnsupportedOperationException </throws>
 public virtual void Seek(TermEnum termEnum)
 {
     throw new System.NotSupportedException();
 }

 public virtual void  Seek(TermEnum termEnum)
 {
     Seek(termEnum.Term);
 	var multiTermEnum = termEnum as MultiTermEnum;
 	if (multiTermEnum != null)
 	{
 		tenum = multiTermEnum;
 		if (topReader != tenum.topReader)
 			tenum = null;
 	}
 }

			public virtual void  Seek(TermEnum termEnum)
			{
				Seek(termEnum.Term());
			}

			public ParallelTermEnum(ParallelReader enclosingInstance)
			{
				InitBlock(enclosingInstance);
				try
				{
					field = Enclosing_Instance.fieldToReader.Keys.First();
				}
				catch (ArgumentOutOfRangeException)
				{
					// No fields, so keep field == null, termEnum == null
					return;
				}
				if (field != null)
					termEnum = Enclosing_Instance.fieldToReader[field].Terms();
			}

        private static void IndexFile(IndexWriter writer, TermEnum uidIter, FileInfo file, Operation operation)
        {
            if (file.FullName.EndsWith(".html") || file.FullName.EndsWith(".htm") || file.FullName.EndsWith(".txt"))
            {
                // We've found a file we should index.
                
                if (operation == Operation.IncrementalReindex ||
                    operation == Operation.RemoveStale)
                {
                    // We should only get here with an open uidIter.
                    Debug.Assert(uidIter != null, "Expected uidIter != null for operation " + operation);

                    var uid = HTMLDocument.Uid(file); // construct uid for doc
                    
                    while (uidIter.Term != null && uidIter.Term.Field == "uid" && String.CompareOrdinal(uidIter.Term.Text, uid) < 0)
                    {
                        if (operation == Operation.RemoveStale)
                        {
                            Console.Out.WriteLine("deleting " + HTMLDocument.Uid2url(uidIter.Term.Text));
                            writer.DeleteDocuments(uidIter.Term);
                        }
                        uidIter.Next();
                    }

                    // The uidIter TermEnum should now be pointing at either
                    //  1) a null term, meaning there are no more uids to check.
                    //  2) a term matching the current file.
                    //  3) a term not matching us.
                    if (uidIter.Term != null && uidIter.Term.Field == "uid" && String.CompareOrdinal(uidIter.Term.Text, uid) == 0)
                    {
                        // uidIter points to the current document, we should move one
                        // step ahead to keep state consistant, and carry on.
                        uidIter.Next();
                    }
                    else if (operation == Operation.IncrementalReindex)
                    {
                        // uidIter does not point to the current document, and we're
                        // currently indexing documents.
                        var doc = HTMLDocument.Document(file);
                        Console.Out.WriteLine("adding " + doc.Get("path"));
                        writer.AddDocument(doc);
                    }
                }
                else
                {
                    // We're doing a complete reindexing. We aren't using uidIter,
                    // but for completeness we assert that it's null (as expected).
                    Debug.Assert(uidIter == null, "Expected uidIter == null for operation == " + operation);

                    var doc = HTMLDocument.Document(file);
                    Console.Out.WriteLine("adding " + doc.Get("path"));
                    writer.AddDocument(doc);
                }
            }
        }

 public void Seek(TermEnum termEnum)
 {
     throw new NotSupportedException();
 }

 public SeekStatus Seek(String value)
 {
     termEnum = reader.Terms(new Term(this.fieldName, value));
     Term t = Term();
     if (t == null)
         return SeekStatus.END;
     return (t.Text.Equals(value)) ? SeekStatus.FOUND : SeekStatus.NOT_FOUND;
 }

			public override bool Next()
			{
				if (termEnum == null)
					return false;
				
				// another term in this field?
				if (termEnum.Next() && (System.Object) termEnum.Term().Field() == (System.Object) field)
					return true; // yes, keep going
				
				termEnum.Close(); // close old termEnum
				
				// find the next field with terms, if any
				if (fieldIterator == null)
				{
                    System.Collections.Comparer comparer = System.Collections.Comparer.Default;
                    System.Collections.SortedList newList = new System.Collections.SortedList();
                    if (Enclosing_Instance.fieldToReader != null)
                    {
                        if (Enclosing_Instance.fieldToReader.Count > 0)
                        {
                            int index = 0;
                            while (comparer.Compare(Enclosing_Instance.fieldToReader.GetKey(index), field) < 0)
                                index++;
                            for (; index < Enclosing_Instance.fieldToReader.Count; index++)
                            {
                                newList.Add(Enclosing_Instance.fieldToReader.GetKey(index), Enclosing_Instance.fieldToReader[Enclosing_Instance.fieldToReader.GetKey(index)]);
                            }
                        }
                    }

                    fieldIterator = newList.Keys.GetEnumerator();
                    fieldIterator.MoveNext();
					System.Object generatedAux = fieldIterator.Current; // Skip field to get next one
				}
				while (fieldIterator.MoveNext())
				{
					field = ((System.String) fieldIterator.Current);
					termEnum = ((IndexReader) Enclosing_Instance.fieldToReader[field]).Terms(new Term(field));
					Term term = termEnum.Term();
					if (term != null && (System.Object) term.Field() == (System.Object) field)
						return true;
					else
						termEnum.Close();
				}
				
				return false; // no more fields
			}

			public override bool Next()
			{
				if (field == null)
					return false;
				
				bool next = termEnum.Next();
				
				// still within field?
				if (next && (System.Object) termEnum.Term().Field() == (System.Object) field)
					return true; // yes, keep going
				
				termEnum.Close(); // close old termEnum
				
				// find the next field, if any
				field = ((System.String) SupportClass.TailMap(Enclosing_Instance.fieldToReader, field).GetKey(0));
				if (field != null)
				{
					termEnum = ((IndexReader) Enclosing_Instance.fieldToReader[field]).Terms();
					return true;
				}
				
				return false; // no more fields
			}