public FieldSortedHitQueue(IndexReader reader,
    SortField[] fields,
    int size) throws IOException 
{
    final int n = fields.length;
    comparators = new ScoreDocComparator[n];
    this.fields = new SortField[n];
    for (int i=0; i< n; ++i) {
      String fieldname = fields[i].getField();
      comparators[i] = getCachedComparator (reader, fieldname, fields[i].getType(), fields[i].getLocale(), fields[i].getFactory());
      if (comparators[i].sortType() == SortField.STRING) {
    	  this.fields[i] = new SortField (fieldname, fields[i].getLocale(), fields[i].getReverse());
      } else {
    	  this.fields[i] = new SortField (fieldname, comparators[i].sortType(), fields[i].getReverse());
      }
    }
    initialize (size);
}

Creates a hit queue sorted by the given list of fields.

Parameters:

reader - Index to use.

fields - Fieldable names, in priority order (highest priority first). Cannot be null or empty.

size - The number of hits to retain. Must be greater than zero.

Throws:

IOException -

 static ScoreDocComparator comparatorAuto(IndexReader reader,
    String fieldname) throws IOException 
{
    final String field = fieldname.intern();
    Object lookupArray = ExtendedFieldCache.EXT_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 long[]) {
      return comparatorLong (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+"'");
    }
}

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.

 static ScoreDocComparator comparatorByte(IndexReader reader,
    String fieldname) throws IOException 
{
                                              
    final String field = fieldname.intern();
    final byte[] fieldOrder = FieldCache.DEFAULT.getBytes(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 Byte(fieldOrder[i.doc]);
      }
      public int sortType() {
        return SortField.INT;
      }
    };
}

Returns a comparator for sorting hits according to a field containing bytes.

 static ScoreDocComparator comparatorDouble(IndexReader reader,
    String fieldname) throws IOException 
{
    final String field = fieldname.intern();
    final double[] fieldOrder = ExtendedFieldCache.EXT_DEFAULT.getDoubles (reader, field);
    return new ScoreDocComparator () {
      public final int compare (final ScoreDoc i, final ScoreDoc j) {
        final double di = fieldOrder[i.doc];
        final double dj = fieldOrder[j.doc];
        if (di <  dj) return -1;
        if (di  > dj) return 1;
        return 0;
      }
      public Comparable sortValue (final ScoreDoc i) {
        return new Double (fieldOrder[i.doc]);
      }
      public int sortType() {
        return SortField.DOUBLE;
      }
    };
}

Returns a comparator for sorting hits according to a field containing doubles.

 static ScoreDocComparator comparatorFloat(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;
      }
    };
}

Returns a comparator for sorting hits according to a field containing floats.

 static ScoreDocComparator comparatorInt(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;
      }
    };
}

Returns a comparator for sorting hits according to a field containing integers.

 static ScoreDocComparator comparatorLong(IndexReader reader,
    String fieldname) throws IOException 
{
    final String field = fieldname.intern();
    final long[] fieldOrder = ExtendedFieldCache.EXT_DEFAULT.getLongs (reader, field);
    return new ScoreDocComparator() {
      public final int compare (final ScoreDoc i, final ScoreDoc j) {
        final long li = fieldOrder[i.doc];
        final long lj = fieldOrder[j.doc];
        if (li <  lj) return -1;
        if (li  > lj) return 1;
        return 0;
      }
      public Comparable sortValue (final ScoreDoc i) {
        return new Long(fieldOrder[i.doc]);
      }
      public int sortType() {
        return SortField.LONG;
      }
    };
}

Returns a comparator for sorting hits according to a field containing integers.

 static ScoreDocComparator comparatorShort(IndexReader reader,
    String fieldname) throws IOException 
{
    final String field = fieldname.intern();
    final short[] fieldOrder = FieldCache.DEFAULT.getShorts(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 Short(fieldOrder[i.doc]);
      }
      public int sortType() {
        return SortField.SHORT;
      }
    };
}

Returns a comparator for sorting hits according to a field containing shorts.

 static ScoreDocComparator comparatorString(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;
      }
    };
}

Returns a comparator for sorting hits according to a field containing strings.

 static ScoreDocComparator comparatorStringLocale(IndexReader reader,
    String fieldname,
    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 a field containing strings.

 FieldDoc fillFields(FieldDoc doc) 
{
    final int n = comparators.length;
    final Comparable[] fields = new Comparable[n];
    for (int i=0; i< n; ++i)
      fields[i] = comparators[i].sortValue(doc);
    doc.fields = fields;
    //if (maxscore  > 1.0f) doc.score /= maxscore;   // normalize scores
    return doc;
}

Given a FieldDoc object, stores the values used to sort the given document. These values are not the raw values out of the index, but the internal representation of them. This is so the given search hit can be collated by a MultiSearcher with other search hits.

 static ScoreDocComparator getCachedComparator(IndexReader reader,
    String field,
    int type,
    Locale locale,
    SortComparatorSource factory) throws IOException 
{
    if (type == SortField.DOC) return ScoreDocComparator.INDEXORDER;
    if (type == SortField.SCORE) return ScoreDocComparator.RELEVANCE;
    FieldCacheImpl.Entry entry = (factory != null)
      ? new FieldCacheImpl.Entry (field, factory)
      : new FieldCacheImpl.Entry (field, type, locale);
    return (ScoreDocComparator)Comparators.get(reader, entry);
}

 SortField[] getFields() 
{
    return fields;
}

Returns the SortFields being used by this hit queue.

 public float getMaxScore() 
{
               
    return maxscore;
}

returns the maximum score encountered by elements inserted via insert()

 public boolean insert(FieldDoc fdoc) 
{
    updateMaxScore(fdoc);
    return super.insert(fdoc);
}

 public boolean insert(Object fdoc) 
{
    return insert((FieldDoc)fdoc);
}

 public Object insertWithOverflow(Object element) 
{
    updateMaxScore((FieldDoc) element);
    return super.insertWithOverflow(element);
}

 protected boolean lessThan(Object a,
    Object b) 
{
    final ScoreDoc docA = (ScoreDoc) a;
    final ScoreDoc docB = (ScoreDoc) b;
    // run comparators
    final int n = comparators.length;
    int c = 0;
    for (int i=0; i< n && c==0; ++i) {
      c = (fields[i].reverse) ? comparators[i].compare (docB, docA)
                              : comparators[i].compare (docA, docB);
    }
    // avoid random sort order that could lead to duplicates (bug #31241):
    if (c == 0)
      return docA.doc  > docB.doc;
    return c  > 0;
}

Returns whether a is less relevant than b.