Index: C:/Workspace/lucene-trunk/src/java/org/apache/lucene/search/IntComparatorSource.java
===================================================================
--- C:/Workspace/lucene-trunk/src/java/org/apache/lucene/search/IntComparatorSource.java	(revision 0)
+++ C:/Workspace/lucene-trunk/src/java/org/apache/lucene/search/IntComparatorSource.java	(revision 0)
@@ -0,0 +1,49 @@
+/**
+ * 
+ */
+package org.apache.lucene.search;
+
+import java.io.IOException;
+
+import org.apache.lucene.index.IndexReader;
+
+final class IntComparatorSource implements SortComparatorSource {
+  private static final long serialVersionUID = 1L;
+
+  /**
+   * Returns a comparator for sorting hits according to a field containing
+   * integers.
+   *
+   * @param reader
+   *          Index to use.
+   * @param fieldname
+   *          Fieldable containg integer values.
+   * @return Comparator for sorting hits.
+   * @throws IOException
+   *           If an error occurs reading the index.
+   */
+  public ScoreDocComparator newComparator(IndexReader reader, String fieldname)
+      throws IOException {
+    final String field = fieldname.intern();
+    final int[] fieldOrder = FieldCache.DEFAULT.getInts (reader, field);
+    return new ScoreDocComparator() {
+
+      public final int compare (final ScoreDoc i, final ScoreDoc j) {
+        final int fi = fieldOrder[i.doc];
+        final int fj = fieldOrder[j.doc];
+        if (fi < fj) return -1;
+        if (fi > fj) return 1;
+        return 0;
+      }
+
+      public Comparable sortValue (final ScoreDoc i) {
+        return new Integer (fieldOrder[i.doc]);
+      }
+
+      public int sortType() {
+        return SortField.INT;
+      }
+    };
+  }
+
+}
\ No newline at end of file
Index: C:/Workspace/lucene-trunk/src/java/org/apache/lucene/search/FloatComparatorSource.java
===================================================================
--- C:/Workspace/lucene-trunk/src/java/org/apache/lucene/search/FloatComparatorSource.java	(revision 0)
+++ C:/Workspace/lucene-trunk/src/java/org/apache/lucene/search/FloatComparatorSource.java	(revision 0)
@@ -0,0 +1,42 @@
+/**
+ * 
+ */
+package org.apache.lucene.search;
+
+import java.io.IOException;
+
+import org.apache.lucene.index.IndexReader;
+
+public class FloatComparatorSource implements SortComparatorSource {
+  private static final long serialVersionUID = 1L;
+
+  /**
+   * Returns a comparator for sorting hits according to a field containing floats.
+   * @param reader  Index to use.
+   * @param fieldname  Fieldable containg float values.
+   * @return  Comparator for sorting hits.
+   * @throws IOException If an error occurs reading the index.
+   */
+  public ScoreDocComparator newComparator(IndexReader reader, String fieldname) throws IOException {
+    final String field = fieldname.intern();
+    final float[] fieldOrder = FieldCache.DEFAULT.getFloats (reader, field);
+    return new ScoreDocComparator () {
+
+      public final int compare (final ScoreDoc i, final ScoreDoc j) {
+        final float fi = fieldOrder[i.doc];
+        final float fj = fieldOrder[j.doc];
+        if (fi < fj) return -1;
+        if (fi > fj) return 1;
+        return 0;
+      }
+
+      public Comparable sortValue (final ScoreDoc i) {
+        return new Float (fieldOrder[i.doc]);
+      }
+
+      public int sortType() {
+        return SortField.FLOAT;
+      }
+    };
+  }
+}
\ No newline at end of file
Index: C:/Workspace/lucene-trunk/src/java/org/apache/lucene/search/FieldSortedHitQueue.java
===================================================================
--- C:/Workspace/lucene-trunk/src/java/org/apache/lucene/search/FieldSortedHitQueue.java	(revision 518792)
+++ C:/Workspace/lucene-trunk/src/java/org/apache/lucene/search/FieldSortedHitQueue.java	(working copy)
@@ -22,7 +22,6 @@
 
 import java.io.IOException;
 import java.util.Locale;
-import java.text.Collator;
 
 /**
  * Expert: A hit queue for sorting by hits by terms in more than one field.
@@ -169,17 +167,20 @@
       ScoreDocComparator comparator;
       switch (type) {
         case SortField.AUTO:
-          comparator = comparatorAuto (reader, fieldname);
+          comparator = new AutoComparatorSource().newComparator(reader, fieldname);
           break;
         case SortField.INT:
-          comparator = comparatorInt (reader, fieldname);
+          comparator = new IntComparatorSource().newComparator(reader, fieldname);
           break;
         case SortField.FLOAT:
-          comparator = comparatorFloat (reader, fieldname);
+          comparator = new FloatComparatorSource().newComparator(reader, fieldname);
           break;
         case SortField.STRING:
-          if (locale != null) comparator = comparatorStringLocale (reader, fieldname, locale);
-          else comparator = comparatorString (reader, fieldname);
+          if (locale != null) {
+            comparator = new StringLocaleComparatorSource(locale).newComparator(reader, fieldname);
+          } else {
+            comparator = new StringComparatorSource().newComparator(reader, fieldname);
+          }
           break;
         case SortField.CUSTOM:
           comparator = factory.newComparator (reader, fieldname);
@@ -190,162 +191,4 @@
       return comparator;
     }
   };
-
-  /**
-   * Returns a comparator for sorting hits according to a field containing integers.
-   * @param reader  Index to use.
-   * @param fieldname  Fieldable containg integer values.
-   * @return  Comparator for sorting hits.
-   * @throws IOException If an error occurs reading the index.
-   */
-  static ScoreDocComparator comparatorInt (final IndexReader reader, final String fieldname)
-  throws IOException {
-    final String field = fieldname.intern();
-    final int[] fieldOrder = FieldCache.DEFAULT.getInts (reader, field);
-    return new ScoreDocComparator() {
-
-      public final int compare (final ScoreDoc i, final ScoreDoc j) {
-        final int fi = fieldOrder[i.doc];
-        final int fj = fieldOrder[j.doc];
-        if (fi < fj) return -1;
-        if (fi > fj) return 1;
-        return 0;
-      }
-
-      public Comparable sortValue (final ScoreDoc i) {
-        return new Integer (fieldOrder[i.doc]);
-      }
-
-      public int sortType() {
-        return SortField.INT;
-      }
-    };
-  }
-
-  /**
-   * Returns a comparator for sorting hits according to a field containing floats.
-   * @param reader  Index to use.
-   * @param fieldname  Fieldable containg float values.
-   * @return  Comparator for sorting hits.
-   * @throws IOException If an error occurs reading the index.
-   */
-  static ScoreDocComparator comparatorFloat (final IndexReader reader, final String fieldname)
-  throws IOException {
-    final String field = fieldname.intern();
-    final float[] fieldOrder = FieldCache.DEFAULT.getFloats (reader, field);
-    return new ScoreDocComparator () {
-
-      public final int compare (final ScoreDoc i, final ScoreDoc j) {
-        final float fi = fieldOrder[i.doc];
-        final float fj = fieldOrder[j.doc];
-        if (fi < fj) return -1;
-        if (fi > fj) return 1;
-        return 0;
-      }
-
-      public Comparable sortValue (final ScoreDoc i) {
-        return new Float (fieldOrder[i.doc]);
-      }
-
-      public int sortType() {
-        return SortField.FLOAT;
-      }
-    };
-  }
-
-  /**
-   * Returns a comparator for sorting hits according to a field containing strings.
-   * @param reader  Index to use.
-   * @param fieldname  Fieldable containg string values.
-   * @return  Comparator for sorting hits.
-   * @throws IOException If an error occurs reading the index.
-   */
-  static ScoreDocComparator comparatorString (final IndexReader reader, final String fieldname)
-  throws IOException {
-    final String field = fieldname.intern();
-    final FieldCache.StringIndex index = FieldCache.DEFAULT.getStringIndex (reader, field);
-    return new ScoreDocComparator () {
-
-      public final int compare (final ScoreDoc i, final ScoreDoc j) {
-        final int fi = index.order[i.doc];
-        final int fj = index.order[j.doc];
-        if (fi < fj) return -1;
-        if (fi > fj) return 1;
-        return 0;
-      }
-
-      public Comparable sortValue (final ScoreDoc i) {
-        return index.lookup[index.order[i.doc]];
-      }
-
-      public int sortType() {
-        return SortField.STRING;
-      }
-    };
-  }
-
-  /**
-   * Returns a comparator for sorting hits according to a field containing strings.
-   * @param reader  Index to use.
-   * @param fieldname  Fieldable containg string values.
-   * @return  Comparator for sorting hits.
-   * @throws IOException If an error occurs reading the index.
-   */
-  static ScoreDocComparator comparatorStringLocale (final IndexReader reader, final String fieldname, final Locale locale)
-  throws IOException {
-    final Collator collator = Collator.getInstance (locale);
-    final String field = fieldname.intern();
-    final String[] index = FieldCache.DEFAULT.getStrings (reader, field);
-    return new ScoreDocComparator() {
-
-    	public final int compare(final ScoreDoc i, final ScoreDoc j) {
-			String is = index[i.doc];
-			String js = index[j.doc];
-			if (is == js) {
-				return 0;
-			} else if (is == null) {
-				return -1;
-			} else if (js == null) {
-				return 1;
-			} else {
-				return collator.compare(is, js);
-			}
-		}
-
-      public Comparable sortValue (final ScoreDoc i) {
-        return index[i.doc];
-      }
-
-      public int sortType() {
-        return SortField.STRING;
-      }
-    };
-  }
-
-  /**
-   * Returns a comparator for sorting hits according to values in the given field.
-   * The terms in the field are looked at to determine whether they contain integers,
-   * floats or strings.  Once the type is determined, one of the other static methods
-   * in this class is called to get the comparator.
-   * @param reader  Index to use.
-   * @param fieldname  Fieldable containg values.
-   * @return  Comparator for sorting hits.
-   * @throws IOException If an error occurs reading the index.
-   */
-  static ScoreDocComparator comparatorAuto (final IndexReader reader, final String fieldname)
-  throws IOException {
-    final String field = fieldname.intern();
-    Object lookupArray = FieldCache.DEFAULT.getAuto (reader, field);
-    if (lookupArray instanceof FieldCache.StringIndex) {
-      return comparatorString (reader, field);
-    } else if (lookupArray instanceof int[]) {
-      return comparatorInt (reader, field);
-    } else if (lookupArray instanceof float[]) {
-      return comparatorFloat (reader, field);
-    } else if (lookupArray instanceof String[]) {
-      return comparatorString (reader, field);
-    } else {
-      throw new RuntimeException ("unknown data type in field '"+field+"'");
-    }
-  }
 }
Index: C:/Workspace/lucene-trunk/src/java/org/apache/lucene/search/AutoComparatorSource.java
===================================================================
--- C:/Workspace/lucene-trunk/src/java/org/apache/lucene/search/AutoComparatorSource.java	(revision 0)
+++ C:/Workspace/lucene-trunk/src/java/org/apache/lucene/search/AutoComparatorSource.java	(revision 0)
@@ -0,0 +1,46 @@
+/**
+ * 
+ */
+package org.apache.lucene.search;
+
+import java.io.IOException;
+
+import org.apache.lucene.index.IndexReader;
+
+class AutoComparatorSource implements SortComparatorSource {
+  private final SortComparatorSource stringSource = new StringComparatorSource();
+  private final SortComparatorSource intSource = new IntComparatorSource();
+  private final SortComparatorSource floatSource = new FloatComparatorSource();
+
+  /**
+   * Returns a comparator for sorting hits according to values in the given
+   * field. The terms in the field are looked at to determine whether they
+   * contain integers, floats or strings. Once the type is determined, one of
+   * the other static methods in this class is called to get the comparator.
+   *
+   * @param reader
+   *          Index to use.
+   * @param fieldname
+   *          Fieldable containg values.
+   * @return Comparator for sorting hits.
+   * @throws IOException
+   *           If an error occurs reading the index.
+   */
+  public ScoreDocComparator newComparator(IndexReader reader, String fieldname)
+      throws IOException {
+    final String field = fieldname.intern();
+    Object lookupArray = FieldCache.DEFAULT.getAuto(reader, field);
+    if (lookupArray instanceof FieldCache.StringIndex) {
+      return stringSource.newComparator(reader, field);
+    } else if (lookupArray instanceof int[]) {
+      return intSource.newComparator(reader, field);
+    } else if (lookupArray instanceof float[]) {
+      return floatSource.newComparator(reader, field);
+    } else if (lookupArray instanceof String[]) {
+      return stringSource.newComparator(reader, field);
+    } else {
+      throw new RuntimeException("unknown data type in field '" + field + "'");
+    }
+  }
+
+}
\ No newline at end of file
Index: C:/Workspace/lucene-trunk/src/java/org/apache/lucene/search/StringLocaleComparatorSource.java
===================================================================
--- C:/Workspace/lucene-trunk/src/java/org/apache/lucene/search/StringLocaleComparatorSource.java	(revision 0)
+++ C:/Workspace/lucene-trunk/src/java/org/apache/lucene/search/StringLocaleComparatorSource.java	(revision 0)
@@ -0,0 +1,63 @@
+/**
+ * 
+ */
+package org.apache.lucene.search;
+
+import java.io.IOException;
+import java.text.Collator;
+import java.util.Locale;
+
+import org.apache.lucene.index.IndexReader;
+
+class StringLocaleComparatorSource implements SortComparatorSource {
+  final Locale locale;
+
+  public StringLocaleComparatorSource(Locale locale) {
+    this.locale = locale;
+  }
+
+  /**
+   * Returns a comparator for sorting hits according to a field containing
+   * strings.
+   *
+   * @param reader
+   *          Index to use.
+   * @param fieldname
+   *          Fieldable containg string values.
+   * @return Comparator for sorting hits.
+   * @throws IOException
+   *           If an error occurs reading the index.
+   */
+
+  public ScoreDocComparator newComparator(IndexReader reader, String fieldname)
+      throws IOException {
+    final String field = fieldname.intern();
+    final String[] index = FieldCache.DEFAULT.getStrings(reader, field);
+    final Collator collator = Collator.getInstance(locale);
+
+    return new ScoreDocComparator() {
+      public final int compare(final ScoreDoc i, final ScoreDoc j) {
+        String is = index[i.doc];
+        String js = index[j.doc];
+        if (is == js) {
+          return 0;
+        } else if (is == null) {
+          return -1;
+        } else if (js == null) {
+          return 1;
+        } else {
+          return collator.compare(is, js);
+        }
+      }
+
+      public Comparable sortValue(final ScoreDoc i) {
+        return index[i.doc];
+      }
+
+      public int sortType() {
+        return SortField.STRING;
+      }
+    };
+  }
+
+}
\ No newline at end of file
Index: C:/Workspace/lucene-trunk/src/java/org/apache/lucene/search/StringComparatorSource.java
===================================================================
--- C:/Workspace/lucene-trunk/src/java/org/apache/lucene/search/StringComparatorSource.java	(revision 0)
+++ C:/Workspace/lucene-trunk/src/java/org/apache/lucene/search/StringComparatorSource.java	(revision 0)
@@ -0,0 +1,43 @@
+/**
+ * 
+ */
+package org.apache.lucene.search;
+
+import java.io.IOException;
+import java.util.Locale;
+
+import org.apache.lucene.index.IndexReader;
+
+class StringComparatorSource implements SortComparatorSource {
+  private static final long serialVersionUID = 1L;
+
+  /**
+   * Returns a comparator for sorting hits according to a field containing strings.
+   * @param reader  Index to use.
+   * @param fieldname  Fieldable containg string values.
+   * @return  Comparator for sorting hits.
+   * @throws IOException If an error occurs reading the index.
+   */
+  public ScoreDocComparator newComparator(IndexReader reader, String fieldname) throws IOException {
+    final String field = fieldname.intern();
+    final FieldCache.StringIndex index = FieldCache.DEFAULT.getStringIndex (reader, field);
+    return new ScoreDocComparator () {
+
+      public final int compare (final ScoreDoc i, final ScoreDoc j) {
+        final int fi = index.order[i.doc];
+        final int fj = index.order[j.doc];
+        if (fi < fj) return -1;
+        if (fi > fj) return 1;
+        return 0;
+      }
+
+      public Comparable sortValue (final ScoreDoc i) {
+        return index.lookup[index.order[i.doc]];
+      }
+
+      public int sortType() {
+        return SortField.STRING;
+      }
+    };
+  }
+}
\ No newline at end of file