ferret 0.1.3 → 0.1.4

data/lib/ferret/index/index_reader.rb

@@ -62,8 +62,11 @@ module Ferret::Index
         FieldOption.new("TERM_VECTOR_WITH_POSITION_OFFSET")
     end
     
-    # directory:: Directory where IndexReader files reside.
-    # segment_infos:: Used for write-l
+    # To create an IndexReader use the IndexReader.open method. This method
+    # should only be used by subclasses.
+    #
+    # directory::       Directory where IndexReader files reside.
+    # segment_infos::   Used for write-l
     # close_directory:: close the directory when the index reader is closed
     def initialize(directory, segment_infos = nil,
                    close_directory = false, directory_owner = false)
@@ -81,7 +84,24 @@ module Ferret::Index
     end
 
     # Returns an index reader to read the index in the directory
+    #
+    # directory::       This can either be a Directory object or you can pass
+    #                   nil (RamDirectory is created) or a path (FSDirectory
+    #                   is created). If you chose the second or third options,
+    #                   you should leave close_directory as true and infos as
+    #                   nil.
+    # close_directory:: True if you want the IndexReader to close the
+    #                   directory when the IndexReader is closed. You'll want
+    #                   to set this to false if other objects are using the
+    #                   same directory object.
+    # infos::           Expert: This can be used to read an different version
+    #                   of the index but should really be left alone.
     def IndexReader.open(directory, close_directory = true, infos = nil)
+      if directory.nil?
+        directory = Ferret::Store::RAMDirectory.new
+      elsif directory.is_a?(String)
+        directory = Ferret::Store::FSDirectory.new(directory, true)
+      end
       directory.synchronize do # in- & inter-process sync
         commit_lock = directory.make_lock(IndexWriter::COMMIT_LOCK_NAME)
         commit_lock.while_locked() do

data/lib/ferret/index/index_writer.rb

@@ -54,6 +54,9 @@ module Index
     # NOTE:: all options are passed in a hash.
     #
     # dir::               the index directory
+    #
+    # == Options
+    # 
     # analyzer::          the analyzer to use. Defaults to StandardAnalyzer.
     # create::            +true+ to create the index or overwrite the existing
     #                     one +false+ to append to the existing index
@@ -62,17 +65,23 @@ module Index
     # close_dir::         This specifies whether you would this class to close
     #                     the index directory when this class is closed. The
     #                     default is false.
-    def initialize(dir, options = {})
+    # use_compound_file:: Use a compound file to store the index. This is
+    #                     slower than using multiple files but it prevents the
+    #                     too many files open error. This defaults to true.
+    def initialize(dir = nil, options = {})
       super()
-      create = options[:create]||false
-      create_if_missing = options[:create_if_missing]||false
+      create = options[:create] || false
+      create_if_missing = options[:create_if_missing] || false
 
-      if dir.instance_of?(String)
-        @directory = FSDirectory.get_directory(dir, create||create_if_missing)
+      if dir.nil?
+        @directory = Ferret::Store::RAMDirectory.new
+      elsif dir.is_a?(String)
+        @directory = Ferret::Store::FSDirectory.new(dir, create)
       else
         @directory = dir
       end
       @close_dir = options[:close_dir] || false
+      @use_compound_file = (options[:use_compound_file] != false) # ie default true
       @analyzer = options[:analyzer] || Ferret::Analysis::StandardAnalyzer.new
       @merge_factor = DEFAULT_MERGE_FACTOR
       @min_merge_docs = DEFAULT_MIN_MERGE_DOCS
@@ -108,6 +117,8 @@ module Index
           end 
         end
       end
+
+      @info_stream = nil
     end
 
     # Flushes all changes to an index and closes all associated files.
@@ -125,11 +136,11 @@ module Index
 
     # Returns the number of documents currently in this index.
     def doc_count()
-      count = 0
       synchronize() do
+        count = 0
         @segment_infos.each { |si| count += si.doc_count() }
+        return count
       end
-      return count
     end
 
     # Adds a document to this index, using the provided analyzer instead of the
@@ -223,7 +234,7 @@ module Index
         merger = SegmentMerger.new(@directory, merged_name, @term_index_interval)
 
         if (@segment_infos.size() == 1) # add existing index, if any
-          s_reader = SegmentReader.new(@segment_infos[0])
+          s_reader = SegmentReader.get(@segment_infos[0])
           merger << s_reader
           segments_to_delete << s_reader
         end
@@ -232,7 +243,7 @@ module Index
           merger << reader
         end
 
-        doc_count = merger.merge!() # merge 'em
+        doc_count = merger.merge() # merge 'em
 
         @segment_infos.clear() # pop old infos & add new
         @segment_infos << SegmentInfo.new(merged_name, doc_count, @directory)
@@ -241,9 +252,22 @@ module Index
           @directory.make_lock(COMMIT_LOCK_NAME).while_locked(COMMIT_LOCK_TIMEOUT) do
             @segment_infos.write(@directory) # commit changes
             delete_segments(segments_to_delete)
-            return nil
           end
         end
+
+        if @use_compound_file
+          files_to_delete = merger.create_compound_file(merged_name + ".tmp")
+          @directory.synchronize() do # in- & inter-process sync
+            @directory.make_lock(COMMIT_LOCK_NAME).while_locked(COMMIT_LOCK_TIMEOUT) do
+              # make compound file visible for SegmentReaders
+              @directory.rename(merged_name + ".tmp", merged_name + ".cfs")
+              # delete now unused files of segment
+              delete_files_and_write_undeletable(files_to_delete)
+            end
+          end
+        end
+
+        optimize()
       end
     end
 
@@ -379,11 +403,10 @@ module Index
         merged_doc_count = merger.merge()
 
         if (@info_stream != nil)
-          @info_stream.print(" into " + merged_name + " (" + merged_doc_count.to_s + " docs)\n")
+          @info_stream.print(" into #{merged_name} (#{merged_doc_count.to_s} docs)\n")
         end
 
         (max_segment-1).downto(min_segment) {|i| @segment_infos.delete_at(i) }
-        #@segment_infos = @segment_infos[0,min_segment] + @segment_infos[max_segment...-1]
 
         @segment_infos << SegmentInfo.new(merged_name, merged_doc_count, @directory)
 
@@ -394,10 +417,21 @@ module Index
           @directory.make_lock(COMMIT_LOCK_NAME).while_locked(COMMIT_LOCK_TIMEOUT) do
             @segment_infos.write(@directory)     # commit before deleting
             delete_segments(segments_to_delete)  # delete now-unused segments
-            return nil
           end
         end
-        segments_to_delete.size.times {|i| segments_to_delete[i] = nil }
+
+        if @use_compound_file
+          files_to_delete = merger.create_compound_file(merged_name + ".tmp")
+          @directory.synchronize() do # in- & inter-process sync
+            @directory.make_lock(COMMIT_LOCK_NAME).while_locked(COMMIT_LOCK_TIMEOUT) do
+              # make compound file visible for SegmentReaders
+              @directory.rename(merged_name + ".tmp", merged_name + ".cfs")
+              # delete now unused files of segment
+              delete_files_and_write_undeletable(files_to_delete)
+            end
+          end
+        end
+
       end
 
       # Some operating systems (e.g. Windows) don't permit a file to be
@@ -440,6 +474,13 @@ module Index
 
       end
 
+      def delete_files_and_write_undeletable(files)
+        deletable = []
+        try_to_delete_files(read_deleteable_files(), deletable) # try to delete deleteable
+        try_to_delete_files(files, deletable)     # try to delete our files
+        write_deleteable_files(deletable)    # note files we can't delete
+      end
+
       def delete_files(file_names, dir)
         file_names.each do |file_name|
           dir.delete(file_name)

data/lib/ferret/index/multi_reader.rb

@@ -1,133 +1,133 @@
-module Ferret
-  module Index
-    # An IndexReader which reads multiple indexes, appending their content.
-    class MultiReader < IndexReader 
-      attr_reader :max_doc
-
-      # Construct a MultiReader aggregating the named set of (sub)readers.
-      # Directory locking for delete, undeleteAll, and set_norm operations is
-      # left to the subreaders. 
-      #
-      # Note that all subreaders are closed if this Multireader is closed.
-      # sub_readers:: set of (sub)readers
-      # raises:: IOException
-      def initialize(sub_readers, directory = nil, sis = nil, close_dir = false)
-        if (directory)
-          super(directory, sis, close_dir)
-        else
-          super(sub_readers.length == 0 ? nil : sub_readers[0].directory())
+module Ferret::Index
+  # An IndexReader which reads multiple indexes, appending their content.
+  class MultiReader < IndexReader 
+    attr_reader :max_doc
+
+    # Construct a MultiReader aggregating the named set of (sub)readers.
+    # Directory locking for delete, undeleteAll, and set_norm operations is
+    # left to the subreaders. 
+    #
+    # Note that all subreaders are closed if this Multireader is closed.
+    # sub_readers:: set of (sub)readers
+    # raises:: IOException
+    def initialize(sub_readers, directory = nil, sis = nil, close_dir = false)
+      if (directory)
+        super(directory, sis, close_dir)
+      else
+        super(sub_readers.length == 0 ? nil : sub_readers[0].directory())
+      end
+
+      @max_doc = 0
+      @num_docs = -1
+      @has_deletions = false
+
+      @sub_readers = sub_readers
+      @starts = Array.new(@sub_readers.length + 1)    # build starts array
+      @sub_readers.each_with_index do |sub_reader, i|
+        @starts[i] = @max_doc
+        @max_doc += sub_reader.max_doc # compute max_docs
+
+        if @sub_readers[i].has_deletions?
+          @has_deletions = true
         end
-
-        @max_doc = 0
-        @num_docs = -1
-        @has_deletions = false
-
-        @sub_readers = sub_readers
-        @starts = Array.new(@sub_readers.length + 1)    # build starts array
-        @sub_readers.each_with_index do |sub_reader, i|
-          @starts[i] = @max_doc
-          @max_doc += sub_reader.max_doc # compute maxDocs
-
-          if @sub_readers[i].has_deletions?
-            @has_deletions = true
-          end
-        end
-        @starts[@sub_readers.length] = @max_doc
-        @norms_cache = {}
       end
+      @starts[@sub_readers.length] = @max_doc
+      @norms_cache = {}
+    end
 
 
-      # Return an array of term frequency vectors for the specified document.  The
-      # array contains a vector for each vectorized field in the document.  Each
-      # vector vector contains term numbers and frequencies for all terms in a
-      # given vectorized field.  If no such fields existed, the method returns
-      # nil.
-      def get_term_vectors(n)
-        i = reader_index(n)        # find segment num
-        return @sub_readers[i].get_term_vectors(n - @starts[i]); # dispatch to segment
-      end
+    # Return an array of term frequency vectors for the specified document.  The
+    # array contains a vector for each vectorized field in the document.  Each
+    # vector vector contains term numbers and frequencies for all terms in a
+    # given vectorized field.  If no such fields existed, the method returns
+    # nil.
+    def get_term_vectors(n)
+      i = reader_index(n)        # find segment num
+      return @sub_readers[i].get_term_vectors(n - @starts[i]); # dispatch to segment
+    end
 
-      def get_term_vector(n, field)
-         i = reader_index(n)        # find segment num
-        return @sub_readers[i].get_term_vector(n - @starts[i], field)
-      end
+    def get_term_vector(n, field)
+       i = reader_index(n)        # find segment num
+      return @sub_readers[i].get_term_vector(n - @starts[i], field)
+    end
 
-      def num_docs() 
-        synchronize do 
-          if (@num_docs == -1) # check cache
-            n = 0                # cache miss -= 1recompute
-            @sub_readers.each {|reader| n += reader.num_docs()}
-            @num_docs = n
-          end
-          return @num_docs
+    def num_docs() 
+      synchronize do 
+        if (@num_docs == -1) # check cache
+          n = 0                # cache miss -= 1recompute
+          @sub_readers.each {|reader| n += reader.num_docs()}
+          @num_docs = n
         end
+        return @num_docs
       end
+    end
 
-      def get_document(n)
-        i = reader_index(n)                                 # find segment num
-        return @sub_readers[i].get_document(n - @starts[i]) # dispatch to segment reader
-      end
+    def get_document(n)
+      i = reader_index(n)                                 # find segment num
+      return @sub_readers[i].get_document(n - @starts[i]) # dispatch to segment reader
+    end
 
-      def deleted?(n) 
-        i = reader_index(n)                             # find segment num
-        return @sub_readers[i].deleted?(n - @starts[i]) # dispatch to segment reader
-      end
+    def deleted?(n) 
+      i = reader_index(n)                             # find segment num
+      return @sub_readers[i].deleted?(n - @starts[i]) # dispatch to segment reader
+    end
 
-      def has_deletions?()
-        return @has_deletions
-      end
+    def has_deletions?()
+      return @has_deletions
+    end
 
-      def do_delete(n)
-        @num_docs = -1                         # invalidate cache
-        i = reader_index(n)                    # find segment num
-        @sub_readers[i].delete(n - @starts[i]) # dispatch to segment reader
-        @has_deletions = true
-      end
+    def do_delete(n)
+      @num_docs = -1                         # invalidate cache
+      i = reader_index(n)                    # find segment num
+      @sub_readers[i].delete(n - @starts[i]) # dispatch to segment reader
+      @has_deletions = true
+    end
 
-      def do_undelete_all()
-        @num_docs = -1                         # invalidate cache
-        @sub_readers.each {|reader| reader.undelete_all() }
-        @has_deletions = false
-      end
+    def do_undelete_all()
+      @num_docs = -1                         # invalidate cache
+      @sub_readers.each {|reader| reader.undelete_all() }
+      @has_deletions = false
+    end
 
-      def reader_index(n) # find reader for doc n:
-        lo = 0                       # search @starts array
-        hi = @sub_readers.length - 1 # for first element less
-
-        while (hi >= lo) 
-          mid = (lo + hi) >> 1
-          mid_value = @starts[mid]
-          if (n < mid_value)
-            hi = mid - 1
-          elsif (n > mid_value)
-            lo = mid + 1
-          else # found a match
-            while (mid+1 < @sub_readers.length and @starts[mid+1] == mid_value) 
-              mid += 1 # scan to last match
-            end
-            return mid
+    def reader_index(n) # find reader for doc n:
+      lo = 0                       # search @starts array
+      hi = @sub_readers.length - 1 # for first element less
+
+      while (hi >= lo) 
+        mid = (lo + hi) >> 1
+        mid_value = @starts[mid]
+        if (n < mid_value)
+          hi = mid - 1
+        elsif (n > mid_value)
+          lo = mid + 1
+        else # found a match
+          while (mid+1 < @sub_readers.length and @starts[mid+1] == mid_value) 
+            mid += 1 # scan to last match
           end
+          return mid
         end
-        return hi
       end
+      return hi
+    end
 
-      def get_norms(field)
-        synchronize do
-          bytes = @norms_cache[field]
-          if (bytes != nil)
-            return bytes    # cache hit
-          end
+    def get_norms(field)
+      synchronize do
+        bytes = @norms_cache[field]
+        if (bytes != nil)
+          return bytes    # cache hit
+        end
 
-          bytes = " " * @max_doc
-          @sub_readers.length.times do |i|
-            @sub_readers[i].get_norms_into(field, bytes, @starts[i])
-          end
-          @norms_cache[field] = bytes      # update cache
-          return bytes
+        bytes = " " * @max_doc
+        @sub_readers.length.times do |i|
+          @sub_readers[i].get_norms_into(field, bytes, @starts[i])
         end
+        @norms_cache[field] = bytes      # update cache
+        return bytes
       end
+    end
 
-      def get_norms_into(field, buf, offset)
+    def get_norms_into(field, buf, offset)
+      synchronize do
         bytes = @norms_cache[field]
         if (bytes != nil)                            # cache hit
           buf[offset ,@max_doc] = bytes[0, @max_doc]
@@ -138,226 +138,226 @@ module Ferret
           @sub_readers[i].get_norms_into(field, buf, offset + @starts[i])
         end
       end
+    end
 
-      def do_set_norm(n, field, value)
-        @norms_cache.delete(field)                   # clear cache
-        i = reader_index(n)                          # find segment num
-        @sub_readers[i].set_norm(n-@starts[i], field, value); # dispatch
-      end
+    def do_set_norm(n, field, value)
+      @norms_cache.delete(field)                   # clear cache
+      i = reader_index(n)                          # find segment num
+      @sub_readers[i].set_norm(n-@starts[i], field, value); # dispatch
+    end
 
-      def terms()
-        return MultiTermEnum.new(@sub_readers, @starts, nil)
-      end
+    def terms()
+      return MultiTermEnum.new(@sub_readers, @starts, nil)
+    end
 
-      def terms_from(term)
-        return MultiTermEnum.new(@sub_readers, @starts, term)
-      end
+    def terms_from(term)
+      return MultiTermEnum.new(@sub_readers, @starts, term)
+    end
 
-      def doc_freq(t)
-        total = 0          # sum freqs in segments
-        @sub_readers.each {|reader| total += reader.doc_freq(t)}
-        return total
-      end
+    def doc_freq(t)
+      total = 0          # sum freqs in segments
+      @sub_readers.each {|reader| total += reader.doc_freq(t)}
+      return total
+    end
 
-      def term_docs()
-        return MultiTermDocEnum.new(@sub_readers, @starts)
-      end
+    def term_docs()
+      return MultiTermDocEnum.new(@sub_readers, @starts)
+    end
 
-      def term_positions()
-        return MultiTermDocPosEnum.new(@sub_readers, @starts)
-      end
+    def term_positions()
+      return MultiTermDocPosEnum.new(@sub_readers, @starts)
+    end
 
-      def do_commit()
-        @sub_readers.each {|reader| reader.commit() }
-      end
+    def do_commit()
+      @sub_readers.each {|reader| reader.commit() }
+    end
 
-      def do_close()
-        synchronize do
-          @sub_readers.each {|reader| reader.close() }
-        end
+    def do_close()
+      synchronize do
+        @sub_readers.each {|reader| reader.close() }
       end
+    end
 
-      # See IndexReader#get_field_names
-      def get_field_names(field_option = IndexReader::FieldOption::ALL)
-        # maintain a unique set of field names
-        field_set = Set.new
-        @sub_readers.each do |reader|
-          field_set |= reader.get_field_names(field_option)
-        end
-        return field_set
+    # See IndexReader#get_field_names
+    def get_field_names(field_option = IndexReader::FieldOption::ALL)
+      # maintain a unique set of field names
+      field_set = Set.new
+      @sub_readers.each do |reader|
+        field_set |= reader.get_field_names(field_option)
       end
+      return field_set
     end
+  end
 
-    class MultiTermEnum < TermEnum 
+  class MultiTermEnum < TermEnum 
 
-      attr_reader :doc_freq, :term
+    attr_reader :doc_freq, :term
 
-      def initialize(readers, starts, t)
-        @queue = SegmentMergeQueue.new(readers.length)
-        readers.each_index do |i|
-          reader = readers[i]
-          term_enum = nil
-          if (t != nil) 
-            term_enum = reader.terms_from(t)
-          else
-            term_enum = reader.terms()
-          end
-          smi = SegmentMergeInfo.new(starts[i], term_enum, reader)
-
-          if (t == nil and smi.next?) or term_enum.term
-            @queue.push(smi);          # initialize queue
-          else
-            smi.close()
-          end
+    def initialize(readers, starts, t)
+      @queue = SegmentMergeQueue.new(readers.length)
+      readers.each_index do |i|
+        reader = readers[i]
+        term_enum = nil
+        if (t != nil) 
+          term_enum = reader.terms_from(t)
+        else
+          term_enum = reader.terms()
         end
+        smi = SegmentMergeInfo.new(starts[i], term_enum, reader)
 
-        if (t != nil and @queue.size() > 0) 
-          next?()
+        if (t == nil and smi.next?) or term_enum.term
+          @queue.push(smi);          # initialize queue
+        else
+          smi.close()
         end
       end
 
-      def next?()
-        top = @queue.top()
-        if (top == nil) 
-          @term = nil
-          return false
-        end
+      if (t != nil and @queue.size() > 0) 
+        next?()
+      end
+    end
+
+    def next?()
+      top = @queue.top()
+      if (top == nil) 
+        @term = nil
+        return false
+      end
 
-        @term = top.term
-        @doc_freq = 0
+      @term = top.term
+      @doc_freq = 0
 
-        while top and @term == top.term
-          @queue.pop()
-          @doc_freq += top.term_enum.doc_freq() # increment freq
-          if (top.next?)
-            @queue.push(top) # restore queue
-          else
-            top.close()     # done with a segment
-          end
-          top = @queue.top()
+      while top and @term == top.term
+        @queue.pop()
+        @doc_freq += top.term_enum.doc_freq() # increment freq
+        if (top.next?)
+          @queue.push(top) # restore queue
+        else
+          top.close()     # done with a segment
         end
-        return true
+        top = @queue.top()
       end
+      return true
+    end
 
-      def close()
-        @queue.close()
-      end
+    def close()
+      @queue.close()
     end
+  end
 
-    class MultiTermDocEnum < TermDocEnum 
-      attr_accessor :readers, :starts, :term, :base, :pointer, :current
+  class MultiTermDocEnum < TermDocEnum 
+    attr_accessor :readers, :starts, :term, :base, :pointer, :current
 
-      def initialize(readers, starts) 
-        @readers = readers
-        @starts = starts
-        @base = 0
-        @pointer = 0
+    def initialize(readers, starts) 
+      @readers = readers
+      @starts = starts
+      @base = 0
+      @pointer = 0
 
-        @reader_term_docs = Array.new(readers.length)
-      end
+      @reader_term_docs = Array.new(readers.length)
+    end
 
-      def doc
-        return @base + @current.doc()
-      end
+    def doc
+      return @base + @current.doc()
+    end
 
-      def freq
-        return @current.freq()
-      end
+    def freq
+      return @current.freq()
+    end
 
-      def seek(term) 
-        @term = term
-        @base = 0
-        @pointer = 0
-        @current = nil
-      end
+    def seek(term) 
+      @term = term
+      @base = 0
+      @pointer = 0
+      @current = nil
+    end
 
-      def next?
-        if @current and @current.next? 
-          return true
-        elsif @pointer < @readers.length 
-          @base = @starts[@pointer]
-          @current = term_docs(@pointer)
-          @pointer += 1
-          return next?()
-        else
-          return false
-        end
+    def next?
+      if @current and @current.next? 
+        return true
+      elsif @pointer < @readers.length 
+        @base = @starts[@pointer]
+        @current = term_docs(@pointer)
+        @pointer += 1
+        return next?()
+      else
+        return false
       end
+    end
 
-      # Optimized implementation. Unlike the Java version, this method
-      # always returns as many results as it can read.
-      def read(docs, freqs)
-        got = 0
-        last_got = 0
-        needed = docs.length
-
-        while (true) 
-          while @current.nil?
-            if @pointer < @readers.length # begin next segment
-              @base = @starts[@pointer]
-              @current = term_docs(@pointer)
-              @pointer += 1
-            else 
-              return got
-            end
+    # Optimized implementation. Unlike the Java version, this method
+    # always returns as many results as it can read.
+    def read(docs, freqs)
+      got = 0
+      last_got = 0
+      needed = docs.length
+
+      while (true) 
+        while @current.nil?
+          if @pointer < @readers.length # try next segment
+            @base = @starts[@pointer]
+            @current = term_docs(@pointer)
+            @pointer += 1
+          else 
+            return got
           end
-          got = @current.read(docs, freqs, got)
-          if (got == last_got) # none left in segment
-            @current = nil
-          else # got some
-            b = @base        # adjust doc numbers
-            (last_got...got).each {|i| docs[i] += b}
-            if got == needed
-              return got
-            else
-              last_got = got
-            end
+        end
+        got = @current.read(docs, freqs, got)
+        if (got == last_got) # none left in segment
+          @current = nil
+        else # got some
+          b = @base        # adjust doc numbers
+          (last_got...got).each {|i| docs[i] += b}
+          if got == needed
+            return got
+          else
+            last_got = got
           end
         end
       end
+    end
 
-      # As yet unoptimized implementation. 
-      def skip_to(target)
-        begin 
-          return false if not next?
-        end while target > doc()
-        return true
-      end
-
-      def term_docs(i)
-        return nil if (@term == nil)
-        result = @reader_term_docs[i]
-        if (result == nil)
-          result = @reader_term_docs[i] = term_docs_from_reader(@readers[i])
-        end
-        result.seek(@term)
-        return result
-      end
+    # As yet unoptimized implementation. 
+    def skip_to(target)
+      begin 
+        return false if not next?
+      end while target > doc()
+      return true
+    end
 
-      def term_docs_from_reader(reader)
-        return reader.term_docs()
+    def term_docs(i)
+      return nil if (@term == nil)
+      result = @reader_term_docs[i]
+      if (result == nil)
+        result = @reader_term_docs[i] = term_docs_from_reader(@readers[i])
       end
+      result.seek(@term)
+      return result
+    end
 
-      def close()
-        @reader_term_docs.compact.each do |rtd|
-          rtd.close()
-        end
-      end
+    def term_docs_from_reader(reader)
+      return reader.term_docs()
     end
 
-    class MultiTermDocPosEnum < MultiTermDocEnum
-      def initialize(r, s) 
-        super(r,s)
+    def close()
+      @reader_term_docs.compact.each do |rtd|
+        rtd.close()
       end
+    end
+  end
 
-      def term_docs_from_reader(reader)
-        return reader.term_positions()
-      end
+  class MultiTermDocPosEnum < MultiTermDocEnum
+    def initialize(r, s) 
+      super(r,s)
+    end
 
-      def next_position()
-        return @current.next_position()
-      end
+    def term_docs_from_reader(reader)
+      return reader.term_positions()
+    end
 
+    def next_position()
+      return @current.next_position()
     end
+
   end
 end