Index: lucene/src/test/org/apache/lucene/search/TestFilteredQuery.java =================================================================== --- lucene/src/test/org/apache/lucene/search/TestFilteredQuery.java (revision 1091132) +++ lucene/src/test/org/apache/lucene/search/TestFilteredQuery.java Mon Jun 20 20:30:57 NZST 2011 @@ -115,7 +115,7 @@ assertEquals (1, hits[0].doc); QueryUtils.check(random, filteredquery,searcher); - hits = searcher.search (filteredquery, null, 1000, new Sort(new SortField("sorter", SortField.STRING))).scoreDocs; + hits = searcher.search (filteredquery, null, 1000, new Sort(new SortField("sorter", SortField.Type.STRING))).scoreDocs; assertEquals (1, hits.length); assertEquals (1, hits[0].doc); Index: lucene/src/test/org/apache/lucene/search/TestTopDocsMerge.java =================================================================== --- lucene/src/test/org/apache/lucene/search/TestTopDocsMerge.java (revision 1136568) +++ lucene/src/test/org/apache/lucene/search/TestTopDocsMerge.java Mon Jun 20 20:27:59 NZST 2011 @@ -133,16 +133,16 @@ } final List sortFields = new ArrayList(); - sortFields.add(new SortField("string", SortField.STRING, true)); - sortFields.add(new SortField("string", SortField.STRING, false)); - sortFields.add(new SortField("int", SortField.INT, true)); - sortFields.add(new SortField("int", SortField.INT, false)); - sortFields.add(new SortField("float", SortField.FLOAT, true)); - sortFields.add(new SortField("float", SortField.FLOAT, false)); - sortFields.add(new SortField(null, SortField.SCORE, true)); - sortFields.add(new SortField(null, SortField.SCORE, false)); - sortFields.add(new SortField(null, SortField.DOC, true)); - sortFields.add(new SortField(null, SortField.DOC, false)); + sortFields.add(new SortField("string", SortField.Type.STRING, true)); + sortFields.add(new SortField("string", SortField.Type.STRING, false)); + sortFields.add(new SortField("int", SortField.Type.INT, true)); + sortFields.add(new SortField("int", SortField.Type.INT, false)); + sortFields.add(new SortField("float", SortField.Type.FLOAT, true)); + sortFields.add(new SortField("float", SortField.Type.FLOAT, false)); + sortFields.add(new SortField(null, SortField.Type.SCORE, true)); + sortFields.add(new SortField(null, SortField.Type.SCORE, false)); + sortFields.add(new SortField(null, SortField.Type.DOC, true)); + sortFields.add(new SortField(null, SortField.Type.DOC, false)); final int[] docStarts = new int[subSearchers.length]; int docBase = 0; Index: solr/src/java/org/apache/solr/search/function/ValueSource.java =================================================================== --- solr/src/java/org/apache/solr/search/function/ValueSource.java (revision 1137612) +++ solr/src/java/org/apache/solr/search/function/ValueSource.java Tue Jun 21 03:16:17 NZST 2011 @@ -102,7 +102,7 @@ class ValueSourceSortField extends SortField { public ValueSourceSortField(boolean reverse) { - super(description(), SortField.REWRITEABLE, reverse); + super(description(), SortField.Type.REWRITEABLE, reverse); } @Override Index: solr/src/java/org/apache/solr/search/Grouping.java =================================================================== --- solr/src/java/org/apache/solr/search/Grouping.java (revision 1137037) +++ solr/src/java/org/apache/solr/search/Grouping.java Tue Jun 21 02:55:06 NZST 2011 @@ -278,7 +278,7 @@ cacheScores = true; } else { for (SortField field : commands.get(0).groupSort.getSort()) { - if (field.getType() == SortField.SCORE) { + if (field.getType() == SortField.Type.SCORE) { cacheScores = true; break; } Index: lucene/src/java/org/apache/lucene/search/cache/FloatValuesCreator.java =================================================================== --- lucene/src/java/org/apache/lucene/search/cache/FloatValuesCreator.java (revision 1055409) +++ lucene/src/java/org/apache/lucene/search/cache/FloatValuesCreator.java Tue Jun 21 01:33:55 NZST 2011 @@ -61,8 +61,8 @@ } @Override - public int getSortTypeID() { - return SortField.FLOAT; + public SortField.Type getSortType() { + return SortField.Type.FLOAT; } Index: solr/src/test/org/apache/solr/search/TestSort.java =================================================================== --- solr/src/test/org/apache/solr/search/TestSort.java (revision 1065304) +++ solr/src/test/org/apache/solr/search/TestSort.java Tue Jun 21 04:10:13 NZST 2011 @@ -126,13 +126,13 @@ final boolean sortMissingFirst2 = !luceneSort2 && !sortMissingLast2; final boolean reverse2 = r.nextBoolean(); - if (r.nextBoolean()) sfields.add( new SortField(null, SortField.SCORE)); + if (r.nextBoolean()) sfields.add( new SortField(null, SortField.Type.SCORE)); // hit both use-cases of sort-missing-last sfields.add( Sorting.getStringSortField("f", reverse, sortMissingLast, sortMissingFirst) ); if (secondary) { sfields.add( Sorting.getStringSortField("f2", reverse2, sortMissingLast2, sortMissingFirst2) ); } - if (r.nextBoolean()) sfields.add( new SortField(null, SortField.SCORE)); + if (r.nextBoolean()) sfields.add( new SortField(null, SortField.Type.SCORE)); Sort sort = new Sort(sfields.toArray(new SortField[sfields.size()])); Index: solr/src/java/org/apache/solr/search/SolrIndexSearcher.java =================================================================== --- solr/src/java/org/apache/solr/search/SolrIndexSearcher.java (revision 1137612) +++ solr/src/java/org/apache/solr/search/SolrIndexSearcher.java Tue Jun 21 01:27:57 NZST 2011 @@ -1024,7 +1024,7 @@ useFilterCache=true; SortField[] sfields = cmd.getSort().getSort(); for (SortField sf : sfields) { - if (sf.getType() == SortField.SCORE) { + if (sf.getType() == SortField.Type.SCORE) { useFilterCache=false; break; } Index: modules/analysis/common/src/test/org/apache/lucene/collation/CollationTestBase.java =================================================================== --- modules/analysis/common/src/test/org/apache/lucene/collation/CollationTestBase.java (revision 1098532) +++ modules/analysis/common/src/test/org/apache/lucene/collation/CollationTestBase.java Mon Jun 20 20:33:31 NZST 2011 @@ -228,16 +228,16 @@ Query queryX = new TermQuery(new Term ("contents", "x")); Query queryY = new TermQuery(new Term ("contents", "y")); - sort.setSort(new SortField("US", SortField.STRING)); + sort.setSort(new SortField("US", SortField.Type.STRING)); assertMatches(searcher, queryY, sort, usResult); - sort.setSort(new SortField("France", SortField.STRING)); + sort.setSort(new SortField("France", SortField.Type.STRING)); assertMatches(searcher, queryX, sort, frResult); - sort.setSort(new SortField("Sweden", SortField.STRING)); + sort.setSort(new SortField("Sweden", SortField.Type.STRING)); assertMatches(searcher, queryY, sort, svResult); - sort.setSort(new SortField("Denmark", SortField.STRING)); + sort.setSort(new SortField("Denmark", SortField.Type.STRING)); assertMatches(searcher, queryY, sort, dkResult); } Index: solr/src/java/org/apache/solr/search/QueryParsing.java =================================================================== --- solr/src/java/org/apache/solr/search/QueryParsing.java (revision 1133872) +++ solr/src/java/org/apache/solr/search/QueryParsing.java Mon Jun 20 20:44:00 NZST 2011 @@ -321,10 +321,10 @@ if (top) { lst.add(SortField.FIELD_SCORE); } else { - lst.add(new SortField(null, SortField.SCORE, true)); + lst.add(new SortField(null, SortField.Type.SCORE, true)); } } else if (DOCID.equals(field)) { - lst.add(new SortField(null, SortField.DOC, top)); + lst.add(new SortField(null, SortField.Type.DOC, top)); } else { // try to find the field SchemaField sf = req.getSchema().getFieldOrNull(field); Index: solr/src/java/org/apache/solr/schema/ShortField.java =================================================================== --- solr/src/java/org/apache/solr/schema/ShortField.java (revision 1071459) +++ solr/src/java/org/apache/solr/schema/ShortField.java Mon Jun 20 20:44:00 NZST 2011 @@ -45,7 +45,7 @@ @Override public SortField getSortField(SchemaField field, boolean reverse) { field.checkSortability(); - return new SortField(field.name, SortField.SHORT, reverse); + return new SortField(field.name, SortField.Type.SHORT, reverse); } @Override Index: lucene/contrib/misc/src/test/org/apache/lucene/index/TestNRTManager.java =================================================================== --- lucene/contrib/misc/src/test/org/apache/lucene/index/TestNRTManager.java (revision 1136357) +++ lucene/contrib/misc/src/test/org/apache/lucene/index/TestNRTManager.java Mon Jun 20 20:34:05 NZST 2011 @@ -672,7 +672,7 @@ private int runQuery(IndexSearcher s, Query q) throws Exception { s.search(q, 10); - return s.search(q, null, 10, new Sort(new SortField("title", SortField.STRING))).totalHits; + return s.search(q, null, 10, new Sort(new SortField("title", SortField.Type.STRING))).totalHits; } private void smokeTestSearcher(IndexSearcher s) throws Exception { Index: lucene/src/test/org/apache/lucene/search/TestElevationComparator.java =================================================================== --- lucene/src/test/org/apache/lucene/search/TestElevationComparator.java (revision 1136080) +++ lucene/src/test/org/apache/lucene/search/TestElevationComparator.java Mon Jun 20 20:27:59 NZST 2011 @@ -73,7 +73,7 @@ Sort sort = new Sort( new SortField("id", new ElevationComparatorSource(priority), false), - new SortField(null, SortField.SCORE, reversed) + new SortField(null, SortField.Type.SCORE, reversed) ); TopDocsCollector topCollector = TopFieldCollector.create(sort, 50, false, true, true, true); Index: solr/src/test/org/apache/solr/search/QueryParsingTest.java =================================================================== --- solr/src/test/org/apache/solr/search/QueryParsingTest.java (revision 1137612) +++ solr/src/test/org/apache/solr/search/QueryParsingTest.java Tue Jun 21 04:09:47 NZST 2011 @@ -46,57 +46,57 @@ sort = QueryParsing.parseSort("score asc", req); SortField[] flds = sort.getSort(); - assertEquals(flds[0].getType(), SortField.SCORE); + assertEquals(flds[0].getType(), SortField.Type.SCORE); assertTrue(flds[0].getReverse()); sort = QueryParsing.parseSort("weight desc", req); flds = sort.getSort(); - assertEquals(flds[0].getType(), SortField.FLOAT); + assertEquals(flds[0].getType(), SortField.Type.FLOAT); assertEquals(flds[0].getField(), "weight"); assertEquals(flds[0].getReverse(), true); sort = QueryParsing.parseSort("weight desc,bday asc", req); flds = sort.getSort(); - assertEquals(flds[0].getType(), SortField.FLOAT); + assertEquals(flds[0].getType(), SortField.Type.FLOAT); assertEquals(flds[0].getField(), "weight"); assertEquals(flds[0].getReverse(), true); - assertEquals(flds[1].getType(), SortField.LONG); + assertEquals(flds[1].getType(), SortField.Type.LONG); assertEquals(flds[1].getField(), "bday"); assertEquals(flds[1].getReverse(), false); //order aliases sort = QueryParsing.parseSort("weight top,bday asc", req); flds = sort.getSort(); - assertEquals(flds[0].getType(), SortField.FLOAT); + assertEquals(flds[0].getType(), SortField.Type.FLOAT); assertEquals(flds[0].getField(), "weight"); assertEquals(flds[0].getReverse(), true); - assertEquals(flds[1].getType(), SortField.LONG); + assertEquals(flds[1].getType(), SortField.Type.LONG); assertEquals(flds[1].getField(), "bday"); assertEquals(flds[1].getReverse(), false); sort = QueryParsing.parseSort("weight top,bday bottom", req); flds = sort.getSort(); - assertEquals(flds[0].getType(), SortField.FLOAT); + assertEquals(flds[0].getType(), SortField.Type.FLOAT); assertEquals(flds[0].getField(), "weight"); assertEquals(flds[0].getReverse(), true); - assertEquals(flds[1].getType(), SortField.LONG); + assertEquals(flds[1].getType(), SortField.Type.LONG); assertEquals(flds[1].getField(), "bday"); assertEquals(flds[1].getReverse(), false); //test weird spacing sort = QueryParsing.parseSort("weight desc, bday asc", req); flds = sort.getSort(); - assertEquals(flds[0].getType(), SortField.FLOAT); + assertEquals(flds[0].getType(), SortField.Type.FLOAT); assertEquals(flds[0].getField(), "weight"); assertEquals(flds[1].getField(), "bday"); - assertEquals(flds[1].getType(), SortField.LONG); + assertEquals(flds[1].getType(), SortField.Type.LONG); //handles trailing commas sort = QueryParsing.parseSort("weight desc,", req); flds = sort.getSort(); - assertEquals(flds[0].getType(), SortField.FLOAT); + assertEquals(flds[0].getType(), SortField.Type.FLOAT); assertEquals(flds[0].getField(), "weight"); //test functions sort = QueryParsing.parseSort("pow(weight, 2) desc", req); flds = sort.getSort(); - assertEquals(flds[0].getType(), SortField.REWRITEABLE); + assertEquals(flds[0].getType(), SortField.Type.REWRITEABLE); //Not thrilled about the fragility of string matching here, but... //the value sources get wrapped, so the out field is different than the input assertEquals(flds[0].getField(), "pow(float(weight),const(2))"); @@ -104,12 +104,12 @@ //test functions (more deep) sort = QueryParsing.parseSort("sum(product(r_f1,sum(d_f1,t_f1,1.0)),a_f1) asc", req); flds = sort.getSort(); - assertEquals(flds[0].getType(), SortField.REWRITEABLE); + assertEquals(flds[0].getType(), SortField.Type.REWRITEABLE); assertEquals(flds[0].getField(), "sum(product(float(r_f1),sum(float(d_f1),float(t_f1),const(1.0))),float(a_f1))"); sort = QueryParsing.parseSort("pow(weight, 2.0) desc", req); flds = sort.getSort(); - assertEquals(flds[0].getType(), SortField.REWRITEABLE); + assertEquals(flds[0].getType(), SortField.Type.REWRITEABLE); //Not thrilled about the fragility of string matching here, but... //the value sources get wrapped, so the out field is different than the input assertEquals(flds[0].getField(), "pow(float(weight),const(2.0))"); @@ -117,27 +117,27 @@ sort = QueryParsing.parseSort("pow(weight, 2.0) desc, weight desc, bday asc", req); flds = sort.getSort(); - assertEquals(flds[0].getType(), SortField.REWRITEABLE); + assertEquals(flds[0].getType(), SortField.Type.REWRITEABLE); //Not thrilled about the fragility of string matching here, but... //the value sources get wrapped, so the out field is different than the input assertEquals(flds[0].getField(), "pow(float(weight),const(2.0))"); - assertEquals(flds[1].getType(), SortField.FLOAT); + assertEquals(flds[1].getType(), SortField.Type.FLOAT); assertEquals(flds[1].getField(), "weight"); assertEquals(flds[2].getField(), "bday"); - assertEquals(flds[2].getType(), SortField.LONG); + assertEquals(flds[2].getType(), SortField.Type.LONG); //handles trailing commas sort = QueryParsing.parseSort("weight desc,", req); flds = sort.getSort(); - assertEquals(flds[0].getType(), SortField.FLOAT); + assertEquals(flds[0].getType(), SortField.Type.FLOAT); assertEquals(flds[0].getField(), "weight"); //Test literals in functions sort = QueryParsing.parseSort("strdist(foo_s1, \"junk\", jw) desc", req); flds = sort.getSort(); - assertEquals(flds[0].getType(), SortField.REWRITEABLE); + assertEquals(flds[0].getType(), SortField.Type.REWRITEABLE); //the value sources get wrapped, so the out field is different than the input assertEquals(flds[0].getField(), "strdist(str(foo_s1),literal(junk), dist=org.apache.lucene.search.spell.JaroWinklerDistance)"); Index: lucene/src/test/org/apache/lucene/TestSearch.java =================================================================== --- lucene/src/test/org/apache/lucene/TestSearch.java (revision 1091132) +++ lucene/src/test/org/apache/lucene/TestSearch.java Mon Jun 20 20:27:59 NZST 2011 @@ -112,7 +112,7 @@ Sort sort = new Sort(new SortField[] { SortField.FIELD_SCORE, - new SortField("id", SortField.INT)}); + new SortField("id", SortField.Type.INT)}); QueryParser parser = new QueryParser(TEST_VERSION_CURRENT, "contents", analyzer); parser.setPhraseSlop(4); Index: lucene/src/java/org/apache/lucene/search/cache/CachedArrayCreator.java =================================================================== --- lucene/src/java/org/apache/lucene/search/cache/CachedArrayCreator.java (revision 1042888) +++ lucene/src/java/org/apache/lucene/search/cache/CachedArrayCreator.java Tue Jun 21 01:33:55 NZST 2011 @@ -26,6 +26,7 @@ import org.apache.lucene.index.TermsEnum; import org.apache.lucene.search.DocIdSetIterator; import org.apache.lucene.search.FieldCache.Parser; +import org.apache.lucene.search.SortField; import org.apache.lucene.util.Bits; import org.apache.lucene.util.BytesRef; import org.apache.lucene.util.OpenBitSet; @@ -73,7 +74,7 @@ /** Return the type that the array will hold */ public abstract Class getArrayType(); public abstract Parser getParser(); - public abstract int getSortTypeID(); + public abstract SortField.Type getSortType(); protected void setParserAndResetCounts(T value, Parser parser) { Index: solr/src/java/org/apache/solr/schema/IntField.java =================================================================== --- solr/src/java/org/apache/solr/schema/IntField.java (revision 1133805) +++ solr/src/java/org/apache/solr/schema/IntField.java Tue Jun 21 03:11:02 NZST 2011 @@ -40,7 +40,7 @@ @Override public SortField getSortField(SchemaField field,boolean reverse) { field.checkSortability(); - return new SortField(field.name,SortField.INT, reverse); + return new SortField(field.name,SortField.Type.INT, reverse); } @Override Index: lucene/src/test/org/apache/lucene/search/TestDateSort.java =================================================================== --- lucene/src/test/org/apache/lucene/search/TestDateSort.java (revision 1091132) +++ lucene/src/test/org/apache/lucene/search/TestDateSort.java Mon Jun 20 20:30:57 NZST 2011 @@ -79,7 +79,7 @@ public void testReverseDateSort() throws Exception { IndexSearcher searcher = newSearcher(reader); - Sort sort = new Sort(new SortField(DATE_TIME_FIELD, SortField.STRING, true)); + Sort sort = new Sort(new SortField(DATE_TIME_FIELD, SortField.Type.STRING, true)); QueryParser queryParser = new QueryParser(TEST_VERSION_CURRENT, TEXT_FIELD, new MockAnalyzer(random)); Query query = queryParser.parse("Document"); Index: lucene/src/java/org/apache/lucene/search/cache/LongValuesCreator.java =================================================================== --- lucene/src/java/org/apache/lucene/search/cache/LongValuesCreator.java (revision 1055409) +++ lucene/src/java/org/apache/lucene/search/cache/LongValuesCreator.java Tue Jun 21 01:33:55 NZST 2011 @@ -61,8 +61,8 @@ } @Override - public int getSortTypeID() { - return SortField.LONG; + public SortField.Type getSortType() { + return SortField.Type.LONG; } Index: lucene/src/java/org/apache/lucene/search/cache/ShortValuesCreator.java =================================================================== --- lucene/src/java/org/apache/lucene/search/cache/ShortValuesCreator.java (revision 1055409) +++ lucene/src/java/org/apache/lucene/search/cache/ShortValuesCreator.java Tue Jun 21 01:33:55 NZST 2011 @@ -61,8 +61,8 @@ } @Override - public int getSortTypeID() { - return SortField.SHORT; + public SortField.Type getSortType() { + return SortField.Type.SHORT; } Index: lucene/src/java/org/apache/lucene/search/SortField.java =================================================================== --- lucene/src/java/org/apache/lucene/search/SortField.java (revision 1137612) +++ lucene/src/java/org/apache/lucene/search/SortField.java Tue Jun 21 01:33:55 NZST 2011 @@ -39,69 +39,70 @@ */ public class SortField { + public static enum Type { + - /** Sort by document score (relevance). Sort values are Float and higher - * values are at the front. */ + /** Sort by document score (relevance). Sort values are Float and higher + * values are at the front. */ - public static final int SCORE = 0; + SCORE, - /** Sort by document number (index order). Sort values are Integer and lower - * values are at the front. */ + /** Sort by document number (index order). Sort values are Integer and lower + * values are at the front. */ - public static final int DOC = 1; + DOC, - // reserved, in Lucene 2.9, there was a constant: AUTO = 2; - - /** Sort using term values as Strings. Sort values are String and lower - * values are at the front. */ + /** Sort using term values as Strings. Sort values are String and lower + * values are at the front. */ - public static final int STRING = 3; + STRING, - /** Sort using term values as encoded Integers. Sort values are Integer and - * lower values are at the front. */ + /** Sort using term values as encoded Integers. Sort values are Integer and + * lower values are at the front. */ - public static final int INT = 4; + INT, - /** Sort using term values as encoded Floats. Sort values are Float and - * lower values are at the front. */ + /** Sort using term values as encoded Floats. Sort values are Float and + * lower values are at the front. */ - public static final int FLOAT = 5; + FLOAT, - /** Sort using term values as encoded Longs. Sort values are Long and - * lower values are at the front. */ + /** Sort using term values as encoded Longs. Sort values are Long and + * lower values are at the front. */ - public static final int LONG = 6; + LONG, - /** Sort using term values as encoded Doubles. Sort values are Double and - * lower values are at the front. */ + /** Sort using term values as encoded Doubles. Sort values are Double and + * lower values are at the front. */ - public static final int DOUBLE = 7; + DOUBLE, - /** Sort using term values as encoded Shorts. Sort values are Short and - * lower values are at the front. */ + /** Sort using term values as encoded Shorts. Sort values are Short and + * lower values are at the front. */ - public static final int SHORT = 8; + SHORT, - /** Sort using a custom Comparator. Sort values are any Comparable and - * sorting is done according to natural order. */ + /** Sort using a custom Comparator. Sort values are any Comparable and + * sorting is done according to natural order. */ - public static final int CUSTOM = 9; + CUSTOM, - /** Sort using term values as encoded Bytes. Sort values are Byte and - * lower values are at the front. */ + /** Sort using term values as encoded Bytes. Sort values are Byte and + * lower values are at the front. */ - public static final int BYTE = 10; + BYTE, - - /** Sort using term values as Strings, but comparing by - * value (using String.compareTo) for all comparisons. - * This is typically slower than {@link #STRING}, which - * uses ordinals to do the sorting. */ + + /** Sort using term values as Strings, but comparing by + * value (using String.compareTo) for all comparisons. + * This is typically slower than {@link #STRING}, which + * uses ordinals to do the sorting. */ - public static final int STRING_VAL = 11; + STRING_VAL, - /** Sort use byte[] index values. */ + /** Sort use byte[] index values. */ - public static final int BYTES = 12; + BYTES, - /** Force rewriting of SortField using {@link SortField#rewrite(IndexSearcher)} - * before it can be used for sorting */ + /** Force rewriting of SortField using {@link SortField#rewrite(IndexSearcher)} + * before it can be used for sorting */ - public static final int REWRITEABLE = 13; + REWRITEABLE + } /** Represents sorting by document score (relevance). */ - public static final SortField FIELD_SCORE = new SortField(null, SCORE); + public static final SortField FIELD_SCORE = new SortField(null, Type.SCORE); /** Represents sorting by document number (index order). */ - public static final SortField FIELD_DOC = new SortField(null, DOC); + public static final SortField FIELD_DOC = new SortField(null, Type.DOC); private String field; - private int type; // defaults to determining type dynamically + private Type type; // defaults to determining type dynamically boolean reverse = false; // defaults to natural order private CachedArrayCreator creator; public Object missingValue = null; // used for 'sortMissingFirst/Last' @@ -115,7 +116,7 @@ * type is SCORE or DOC. * @param type Type of values in the terms. */ - public SortField(String field, int type) { + public SortField(String field, Type type) { initFieldType(field, type); } @@ -126,7 +127,7 @@ * @param type Type of values in the terms. * @param reverse True if natural order should be reversed. */ - public SortField(String field, int type, boolean reverse) { + public SortField(String field, Type type, boolean reverse) { initFieldType(field, type); this.reverse = reverse; } @@ -170,27 +171,27 @@ this.reverse = reverse; if (parser instanceof FieldCache.IntParser) { - this.type = INT; + this.type = Type.INT; this.creator = new IntValuesCreator( field, (FieldCache.IntParser)parser ); } else if (parser instanceof FieldCache.FloatParser) { - this.type = FLOAT; + this.type = Type.FLOAT; this.creator = new FloatValuesCreator( field, (FieldCache.FloatParser)parser ); } else if (parser instanceof FieldCache.ShortParser) { - this.type = SHORT; + this.type = Type.SHORT; this.creator = new ShortValuesCreator( field, (FieldCache.ShortParser)parser ); } else if (parser instanceof FieldCache.ByteParser) { - this.type = BYTE; + this.type = Type.BYTE; this.creator = new ByteValuesCreator( field, (FieldCache.ByteParser)parser ); } else if (parser instanceof FieldCache.LongParser) { - this.type = LONG; + this.type = Type.LONG; this.creator = new LongValuesCreator( field, (FieldCache.LongParser)parser ); } else if (parser instanceof FieldCache.DoubleParser) { - this.type = DOUBLE; + this.type = Type.DOUBLE; this.creator = new DoubleValuesCreator( field, (FieldCache.DoubleParser)parser ); } else @@ -208,7 +209,7 @@ this.field = StringHelper.intern(creator.field); this.reverse = reverse; this.creator = creator; - this.type = creator.getSortTypeID(); + this.type = creator.getSortType(); } public SortField setMissingValue( Object v ) @@ -230,7 +231,7 @@ * @param comparator Returns a comparator for sorting hits. */ public SortField(String field, FieldComparatorSource comparator) { - initFieldType(field, CUSTOM); + initFieldType(field, Type.CUSTOM); this.comparatorSource = comparator; } @@ -240,17 +241,17 @@ * @param reverse True if natural order should be reversed. */ public SortField(String field, FieldComparatorSource comparator, boolean reverse) { - initFieldType(field, CUSTOM); + initFieldType(field, Type.CUSTOM); this.reverse = reverse; this.comparatorSource = comparator; } // Sets field & type, and ensures field is not NULL unless // type is SCORE or DOC - private void initFieldType(String field, int type) { + private void initFieldType(String field, Type type) { this.type = type; if (field == null) { - if (type != SCORE && type != DOC) + if (type != Type.SCORE && type != Type.DOC) throw new IllegalArgumentException("field can only be null when type is SCORE or DOC"); } else { this.field = StringHelper.intern(field); @@ -280,7 +281,7 @@ /** Returns the type of contents in the field. * @return One of the constants SCORE, DOC, STRING, INT or FLOAT. */ - public int getType() { + public Type getType() { return type; } @@ -396,7 +397,7 @@ * used). */ @Override public int hashCode() { - int hash=type^0x346565dd + Boolean.valueOf(reverse).hashCode()^0xaf5998bb; + int hash = type.hashCode() ^ 0x346565dd + Boolean.valueOf(reverse).hashCode() ^ 0xaf5998bb; if (field != null) hash += field.hashCode()^0xff5685dd; if (comparatorSource != null) hash += comparatorSource.hashCode(); if (creator != null) hash += creator.hashCode()^0x3aaf56ff; @@ -438,49 +439,49 @@ public FieldComparator getComparator(final int numHits, final int sortPos) throws IOException { switch (type) { - case SortField.SCORE: + case SCORE: return new FieldComparator.RelevanceComparator(numHits); - case SortField.DOC: + case DOC: return new FieldComparator.DocComparator(numHits); - case SortField.INT: + case INT: if (useIndexValues) { return new FieldComparator.IntDocValuesComparator(numHits, field); } else { return new FieldComparator.IntComparator(numHits, (IntValuesCreator)creator, (Integer) missingValue); } - case SortField.FLOAT: + case FLOAT: if (useIndexValues) { return new FieldComparator.FloatDocValuesComparator(numHits, field); } else { return new FieldComparator.FloatComparator(numHits, (FloatValuesCreator) creator, (Float) missingValue); } - case SortField.LONG: + case LONG: return new FieldComparator.LongComparator(numHits, (LongValuesCreator)creator, (Long)missingValue ); - case SortField.DOUBLE: + case DOUBLE: return new FieldComparator.DoubleComparator(numHits, (DoubleValuesCreator)creator, (Double)missingValue ); - case SortField.BYTE: + case BYTE: return new FieldComparator.ByteComparator(numHits, (ByteValuesCreator)creator, (Byte)missingValue ); - case SortField.SHORT: + case SHORT: return new FieldComparator.ShortComparator(numHits, (ShortValuesCreator)creator, (Short)missingValue ); - case SortField.CUSTOM: + case CUSTOM: assert comparatorSource != null; return comparatorSource.newComparator(field, numHits, sortPos, reverse); - case SortField.STRING: + case STRING: return new FieldComparator.TermOrdValComparator(numHits, field, sortPos, reverse); - case SortField.STRING_VAL: + case STRING_VAL: return new FieldComparator.TermValComparator(numHits, field); - case SortField.REWRITEABLE: + case REWRITEABLE: throw new IllegalStateException("SortField needs to be rewritten through Sort.rewrite(..) and SortField.rewrite(..)"); default: @@ -491,7 +492,7 @@ /** * Rewrites this SortField, returning a new SortField if a change is made. * Subclasses should override this define their rewriting behavior when this - * SortField is of type {@link SortField#REWRITEABLE} + * SortField is of type {@link SortField.Type#REWRITEABLE} * * @param searcher IndexSearcher to use during rewriting * @return New rewritten SortField, or {@code this} if nothing has changed. Index: solr/src/java/org/apache/solr/schema/DoubleField.java =================================================================== --- solr/src/java/org/apache/solr/schema/DoubleField.java (revision 1133805) +++ solr/src/java/org/apache/solr/schema/DoubleField.java Mon Jun 20 20:44:00 NZST 2011 @@ -42,7 +42,7 @@ @Override public SortField getSortField(SchemaField field, boolean reverse) { field.checkSortability(); - return new SortField(field.name, SortField.DOUBLE, reverse); + return new SortField(field.name, SortField.Type.DOUBLE, reverse); } @Override Index: solr/src/java/org/apache/solr/schema/FloatField.java =================================================================== --- solr/src/java/org/apache/solr/schema/FloatField.java (revision 1133805) +++ solr/src/java/org/apache/solr/schema/FloatField.java Mon Jun 20 20:44:00 NZST 2011 @@ -40,7 +40,7 @@ @Override public SortField getSortField(SchemaField field,boolean reverse) { field.checkSortability(); - return new SortField(field.name,SortField.FLOAT, reverse); + return new SortField(field.name,SortField.Type.FLOAT, reverse); } @Override Index: lucene/src/test/org/apache/lucene/index/TestNRTThreads.java =================================================================== --- lucene/src/test/org/apache/lucene/index/TestNRTThreads.java (revision 1137208) +++ lucene/src/test/org/apache/lucene/index/TestNRTThreads.java Mon Jun 20 20:27:59 NZST 2011 @@ -579,7 +579,7 @@ private int runQuery(IndexSearcher s, Query q) throws Exception { s.search(q, 10); - return s.search(q, null, 10, new Sort(new SortField("title", SortField.STRING))).totalHits; + return s.search(q, null, 10, new Sort(new SortField("title", SortField.Type.STRING))).totalHits; } private void smokeTestReader(IndexReader r) throws Exception { Index: solr/src/java/org/apache/solr/schema/LongField.java =================================================================== --- solr/src/java/org/apache/solr/schema/LongField.java (revision 1133805) +++ solr/src/java/org/apache/solr/schema/LongField.java Mon Jun 20 20:44:00 NZST 2011 @@ -42,7 +42,7 @@ @Override public SortField getSortField(SchemaField field,boolean reverse) { field.checkSortability(); - return new SortField(field.name,SortField.LONG, reverse); + return new SortField(field.name,SortField.Type.LONG, reverse); } @Override Index: solr/src/java/org/apache/solr/handler/component/ShardDoc.java =================================================================== --- solr/src/java/org/apache/solr/handler/component/ShardDoc.java (revision 1079707) +++ solr/src/java/org/apache/solr/handler/component/ShardDoc.java Tue Jun 21 03:12:00 NZST 2011 @@ -89,8 +89,8 @@ for (int i = 0; i < n; ++i) { // keep track of the named fields - int type = fields[i].getType(); - if (type!=SortField.SCORE && type!=SortField.DOC) { + SortField.Type type = fields[i].getType(); + if (type!=SortField.Type.SCORE && type!=SortField.Type.DOC) { fieldNames.add(fields[i].getField()); } @@ -98,8 +98,8 @@ comparators[i] = getCachedComparator(fieldname, fields[i] .getType(), fields[i].getComparatorSource()); - if (fields[i].getType() == SortField.STRING) { - this.fields[i] = new SortField(fieldname, SortField.STRING, + if (fields[i].getType() == SortField.Type.STRING) { + this.fields[i] = new SortField(fieldname, SortField.Type.STRING, fields[i].getReverse()); } else { this.fields[i] = new SortField(fieldname, fields[i].getType(), @@ -144,16 +144,16 @@ return c < 0; } - Comparator getCachedComparator(String fieldname, int type, FieldComparatorSource factory) { + Comparator getCachedComparator(String fieldname, SortField.Type type, FieldComparatorSource factory) { Comparator comparator = null; switch (type) { - case SortField.SCORE: + case SCORE: comparator = comparatorScore(fieldname); break; - case SortField.STRING: + case STRING: comparator = comparatorNatural(fieldname); break; - case SortField.CUSTOM: + case CUSTOM: if (factory instanceof MissingStringLastComparatorSource){ comparator = comparatorMissingStringLast(fieldname); } else { @@ -163,7 +163,7 @@ // throw new RuntimeException("Custom sort not supported factory is "+factory.getClass()); } break; - case SortField.DOC: + case DOC: // TODO: we can support this! throw new RuntimeException("Doc sort not supported"); default: Index: solr/src/java/org/apache/solr/search/Sorting.java =================================================================== --- solr/src/java/org/apache/solr/search/Sorting.java (revision 1133805) +++ solr/src/java/org/apache/solr/search/Sorting.java Mon Jun 20 20:45:06 NZST 2011 @@ -42,12 +42,12 @@ public static SortField getStringSortField(String fieldName, boolean reverse, boolean nullLast, boolean nullFirst) { if (nullLast) { if (!reverse) return new SortField(fieldName, nullStringLastComparatorSource); - else return new SortField(fieldName, SortField.STRING, true); + else return new SortField(fieldName, SortField.Type.STRING, true); } else if (nullFirst) { if (reverse) return new SortField(fieldName, nullStringLastComparatorSource, true); - else return new SortField(fieldName, SortField.STRING, false); + else return new SortField(fieldName, SortField.Type.STRING, false); } else { - return new SortField(fieldName, SortField.STRING, reverse); + return new SortField(fieldName, SortField.Type.STRING, reverse); } } Index: solr/src/java/org/apache/solr/handler/component/QueryComponent.java =================================================================== --- solr/src/java/org/apache/solr/handler/component/QueryComponent.java (revision 1137037) +++ solr/src/java/org/apache/solr/handler/component/QueryComponent.java Tue Jun 21 03:12:24 NZST 2011 @@ -435,8 +435,8 @@ } for (SortField sortField: sortFields) { - int type = sortField.getType(); - if (type==SortField.SCORE || type==SortField.DOC) continue; + SortField.Type type = sortField.getType(); + if (type==SortField.Type.SCORE || type==SortField.Type.DOC) continue; FieldComparator comparator = null; FieldComparator comparators[] = (leaves==null) ? null : new FieldComparator[leaves.length]; Index: modules/benchmark/src/java/org/apache/lucene/benchmark/byTask/tasks/SearchWithSortTask.java =================================================================== --- modules/benchmark/src/java/org/apache/lucene/benchmark/byTask/tasks/SearchWithSortTask.java (revision 833867) +++ modules/benchmark/src/java/org/apache/lucene/benchmark/byTask/tasks/SearchWithSortTask.java Mon Jun 20 20:37:07 NZST 2011 @@ -75,7 +75,7 @@ } else { throw new RuntimeException("You must specify the sort type ie page:int,subject:string"); } - int type = getType(typeString); + SortField.Type type = getType(typeString); sortField0 = new SortField(fieldName, type); } sortFields[upto++] = sortField0; @@ -89,24 +89,24 @@ this.sort = new Sort(sortFields); } - private int getType(String typeString) { - int type; + private SortField.Type getType(String typeString) { + SortField.Type type; if (typeString.equals("float")) { - type = SortField.FLOAT; + type = SortField.Type.FLOAT; } else if (typeString.equals("double")) { - type = SortField.DOUBLE; + type = SortField.Type.DOUBLE; } else if (typeString.equals("byte")) { - type = SortField.BYTE; + type = SortField.Type.BYTE; } else if (typeString.equals("short")) { - type = SortField.SHORT; + type = SortField.Type.SHORT; } else if (typeString.equals("int")) { - type = SortField.INT; + type = SortField.Type.INT; } else if (typeString.equals("long")) { - type = SortField.LONG; + type = SortField.Type.LONG; } else if (typeString.equals("string")) { - type = SortField.STRING; + type = SortField.Type.STRING; } else if (typeString.equals("string_val")) { - type = SortField.STRING_VAL; + type = SortField.Type.STRING_VAL; } else { throw new RuntimeException("Unrecognized sort field type " + typeString); } Index: solr/src/java/org/apache/solr/search/SortSpec.java =================================================================== --- solr/src/java/org/apache/solr/search/SortSpec.java (revision 631357) +++ solr/src/java/org/apache/solr/search/SortSpec.java Mon Jun 20 20:44:00 NZST 2011 @@ -48,7 +48,7 @@ public static boolean includesScore(Sort sort) { if (sort==null) return true; for (SortField sf : sort.getSort()) { - if (sf.getType() == SortField.SCORE) return true; + if (sf.getType() == SortField.Type.SCORE) return true; } return false; } Index: lucene/src/java/org/apache/lucene/search/cache/DoubleValuesCreator.java =================================================================== --- lucene/src/java/org/apache/lucene/search/cache/DoubleValuesCreator.java (revision 1055409) +++ lucene/src/java/org/apache/lucene/search/cache/DoubleValuesCreator.java Tue Jun 21 01:33:55 NZST 2011 @@ -61,8 +61,8 @@ } @Override - public int getSortTypeID() { - return SortField.DOUBLE; + public SortField.Type getSortType() { + return SortField.Type.DOUBLE; } //-------------------------------------------------------------------------------- Index: solr/src/java/org/apache/solr/handler/component/QueryElevationComponent.java =================================================================== --- solr/src/java/org/apache/solr/handler/component/QueryElevationComponent.java (revision 1136080) +++ solr/src/java/org/apache/solr/handler/component/QueryElevationComponent.java Mon Jun 20 20:45:06 NZST 2011 @@ -379,7 +379,7 @@ if( sortSpec.getSort() == null ) { sortSpec.setSort( new Sort( new SortField[] { new SortField(idField, booster.comparatorSource, false ), - new SortField(null, SortField.SCORE, false) + new SortField(null, SortField.Type.SCORE, false) })); } else { @@ -388,12 +388,12 @@ SortField[] current = sortSpec.getSort().getSort(); ArrayList sorts = new ArrayList( current.length + 1 ); // Perhaps force it to always sort by score - if( force && current[0].getType() != SortField.SCORE ) { + if( force && current[0].getType() != SortField.Type.SCORE ) { sorts.add( new SortField(idField, booster.comparatorSource, false ) ); modify = true; } for( SortField sf : current ) { - if( sf.getType() == SortField.SCORE ) { + if( sf.getType() == SortField.Type.SCORE ) { sorts.add( new SortField(idField, booster.comparatorSource, sf.getReverse() ) ); modify = true; } Index: lucene/src/java/org/apache/lucene/search/cache/ByteValuesCreator.java =================================================================== --- lucene/src/java/org/apache/lucene/search/cache/ByteValuesCreator.java (revision 1055409) +++ lucene/src/java/org/apache/lucene/search/cache/ByteValuesCreator.java Tue Jun 21 01:33:55 NZST 2011 @@ -61,8 +61,8 @@ } @Override - public int getSortTypeID() { - return SortField.BYTE; + public SortField.Type getSortType() { + return SortField.Type.BYTE; } //-------------------------------------------------------------------------------- Index: lucene/src/test/org/apache/lucene/search/TestSort.java =================================================================== --- lucene/src/test/org/apache/lucene/search/TestSort.java (revision 1136080) +++ lucene/src/test/org/apache/lucene/search/TestSort.java Mon Jun 20 20:27:59 NZST 2011 @@ -283,44 +283,44 @@ } // test sorts where the type of field is specified public void testTypedSort() throws Exception { - sort.setSort (new SortField ("int", SortField.INT), SortField.FIELD_DOC ); + sort.setSort (new SortField ("int", SortField.Type.INT), SortField.FIELD_DOC ); assertMatches (full, queryX, sort, "IGAEC"); assertMatches (full, queryY, sort, "DHFJB"); - sort.setSort (new SortField ("float", SortField.FLOAT), SortField.FIELD_DOC ); + sort.setSort (new SortField ("float", SortField.Type.FLOAT), SortField.FIELD_DOC ); assertMatches (full, queryX, sort, "GCIEA"); assertMatches (full, queryY, sort, "DHJFB"); - sort.setSort (new SortField ("long", SortField.LONG), SortField.FIELD_DOC ); + sort.setSort (new SortField ("long", SortField.Type.LONG), SortField.FIELD_DOC ); assertMatches (full, queryX, sort, "EACGI"); assertMatches (full, queryY, sort, "FBJHD"); - sort.setSort (new SortField ("double", SortField.DOUBLE), SortField.FIELD_DOC ); + sort.setSort (new SortField ("double", SortField.Type.DOUBLE), SortField.FIELD_DOC ); assertMatches (full, queryX, sort, "AGICE"); assertMatches (full, queryY, sort, "DJHBF"); - sort.setSort (new SortField ("byte", SortField.BYTE), SortField.FIELD_DOC ); + sort.setSort (new SortField ("byte", SortField.Type.BYTE), SortField.FIELD_DOC ); assertMatches (full, queryX, sort, "CIGAE"); assertMatches (full, queryY, sort, "DHFBJ"); - sort.setSort (new SortField ("short", SortField.SHORT), SortField.FIELD_DOC ); + sort.setSort (new SortField ("short", SortField.Type.SHORT), SortField.FIELD_DOC ); assertMatches (full, queryX, sort, "IAGCE"); assertMatches (full, queryY, sort, "DFHBJ"); - sort.setSort (new SortField ("string", SortField.STRING), SortField.FIELD_DOC ); + sort.setSort (new SortField ("string", SortField.Type.STRING), SortField.FIELD_DOC ); assertMatches (full, queryX, sort, "AIGEC"); assertMatches (full, queryY, sort, "DJHFB"); if (supportsDocValues) { - sort.setSort (useDocValues(new SortField ("int", SortField.INT)), SortField.FIELD_DOC ); + sort.setSort (useDocValues(new SortField ("int", SortField.Type.INT)), SortField.FIELD_DOC ); assertMatches (full, queryX, sort, "IGAEC"); assertMatches (full, queryY, sort, "DHFJB"); - sort.setSort (useDocValues(new SortField ("float", SortField.FLOAT)), SortField.FIELD_DOC ); + sort.setSort (useDocValues(new SortField ("float", SortField.Type.FLOAT)), SortField.FIELD_DOC ); assertMatches (full, queryX, sort, "GCIEA"); assertMatches (full, queryY, sort, "DHJFB"); - sort.setSort (useDocValues(new SortField ("double", SortField.DOUBLE)), SortField.FIELD_DOC ); + sort.setSort (useDocValues(new SortField ("double", SortField.Type.DOUBLE)), SortField.FIELD_DOC ); assertMatches (full, queryX, sort, "AGICE"); assertMatches (full, queryY, sort, "DJHBF"); } @@ -369,8 +369,8 @@ ScoreDoc[] result = null; IndexSearcher searcher = getFullStrings(); sort.setSort( - new SortField("string", SortField.STRING), - new SortField("string2", SortField.STRING, true), + new SortField("string", SortField.Type.STRING), + new SortField("string2", SortField.Type.STRING, true), SortField.FIELD_DOC); result = searcher.search(new MatchAllDocsQuery(), null, 500, sort).scoreDocs; @@ -495,19 +495,19 @@ sort.setSort(SortField.FIELD_DOC); assertMatches (empty, queryX, sort, ""); - sort.setSort (new SortField ("int", SortField.INT), SortField.FIELD_DOC ); + sort.setSort (new SortField ("int", SortField.Type.INT), SortField.FIELD_DOC ); assertMatches (empty, queryX, sort, ""); - sort.setSort (useDocValues(new SortField ("int", SortField.INT)), SortField.FIELD_DOC ); + sort.setSort (useDocValues(new SortField ("int", SortField.Type.INT)), SortField.FIELD_DOC ); assertMatches (empty, queryX, sort, ""); - sort.setSort (new SortField ("string", SortField.STRING, true), SortField.FIELD_DOC ); + sort.setSort (new SortField ("string", SortField.Type.STRING, true), SortField.FIELD_DOC ); assertMatches (empty, queryX, sort, ""); - sort.setSort (new SortField ("float", SortField.FLOAT), new SortField ("string", SortField.STRING) ); + sort.setSort (new SortField ("float", SortField.Type.FLOAT), new SortField ("string", SortField.Type.STRING) ); assertMatches (empty, queryX, sort, ""); - sort.setSort (useDocValues(new SortField ("float", SortField.FLOAT)), new SortField ("string", SortField.STRING) ); + sort.setSort (useDocValues(new SortField ("float", SortField.Type.FLOAT)), new SortField ("string", SortField.Type.STRING) ); assertMatches (empty, queryX, sort, ""); } @@ -574,32 +574,32 @@ // test sorts in reverse public void testReverseSort() throws Exception { - sort.setSort (new SortField (null, SortField.SCORE, true), SortField.FIELD_DOC ); + sort.setSort (new SortField (null, SortField.Type.SCORE, true), SortField.FIELD_DOC ); assertMatches (full, queryX, sort, "IEGCA"); assertMatches (full, queryY, sort, "JFHDB"); - sort.setSort (new SortField (null, SortField.DOC, true)); + sort.setSort (new SortField (null, SortField.Type.DOC, true)); assertMatches (full, queryX, sort, "IGECA"); assertMatches (full, queryY, sort, "JHFDB"); - sort.setSort (new SortField ("int", SortField.INT, true) ); + sort.setSort (new SortField ("int", SortField.Type.INT, true) ); assertMatches (full, queryX, sort, "CAEGI"); assertMatches (full, queryY, sort, "BJFHD"); - sort.setSort (new SortField ("float", SortField.FLOAT, true) ); + sort.setSort (new SortField ("float", SortField.Type.FLOAT, true) ); assertMatches (full, queryX, sort, "AECIG"); assertMatches (full, queryY, sort, "BFJHD"); - sort.setSort (new SortField ("string", SortField.STRING, true) ); + sort.setSort (new SortField ("string", SortField.Type.STRING, true) ); assertMatches (full, queryX, sort, "CEGIA"); assertMatches (full, queryY, sort, "BFHJD"); if (supportsDocValues) { - sort.setSort (useDocValues(new SortField ("int", SortField.INT, true)) ); + sort.setSort (useDocValues(new SortField ("int", SortField.Type.INT, true)) ); assertMatches (full, queryX, sort, "CAEGI"); assertMatches (full, queryY, sort, "BJFHD"); - sort.setSort (useDocValues(new SortField ("float", SortField.FLOAT, true)) ); + sort.setSort (useDocValues(new SortField ("float", SortField.Type.FLOAT, true)) ); assertMatches (full, queryX, sort, "AECIG"); assertMatches (full, queryY, sort, "BFJHD"); } @@ -607,62 +607,62 @@ // test sorting when the sort field is empty (undefined) for some of the documents public void testEmptyFieldSort() throws Exception { - sort.setSort (new SortField ("string", SortField.STRING) ); + sort.setSort (new SortField ("string", SortField.Type.STRING) ); assertMatches (full, queryF, sort, "ZJI"); - sort.setSort (new SortField ("string", SortField.STRING, true) ); + sort.setSort (new SortField ("string", SortField.Type.STRING, true) ); assertMatches (full, queryF, sort, "IJZ"); - sort.setSort (new SortField ("int", SortField.INT) ); + sort.setSort (new SortField ("int", SortField.Type.INT) ); assertMatches (full, queryF, sort, "IZJ"); - sort.setSort (new SortField ("int", SortField.INT, true) ); + sort.setSort (new SortField ("int", SortField.Type.INT, true) ); assertMatches (full, queryF, sort, "JZI"); - sort.setSort (new SortField ("float", SortField.FLOAT) ); + sort.setSort (new SortField ("float", SortField.Type.FLOAT) ); assertMatches (full, queryF, sort, "ZJI"); if (supportsDocValues) { - sort.setSort (useDocValues(new SortField ("int", SortField.INT)) ); + sort.setSort (useDocValues(new SortField ("int", SortField.Type.INT)) ); assertMatches (full, queryF, sort, "IZJ"); - sort.setSort (useDocValues(new SortField ("float", SortField.FLOAT)) ); + sort.setSort (useDocValues(new SortField ("float", SortField.Type.FLOAT)) ); assertMatches (full, queryF, sort, "ZJI"); } // using a nonexisting field as first sort key shouldn't make a difference: - sort.setSort (new SortField ("nosuchfield", SortField.STRING), - new SortField ("float", SortField.FLOAT) ); + sort.setSort (new SortField ("nosuchfield", SortField.Type.STRING), + new SortField ("float", SortField.Type.FLOAT) ); assertMatches (full, queryF, sort, "ZJI"); - sort.setSort (new SortField ("float", SortField.FLOAT, true) ); + sort.setSort (new SortField ("float", SortField.Type.FLOAT, true) ); assertMatches (full, queryF, sort, "IJZ"); // When a field is null for both documents, the next SortField should be used. // Works for - sort.setSort (new SortField ("int", SortField.INT), - new SortField ("string", SortField.STRING), - new SortField ("float", SortField.FLOAT) ); + sort.setSort (new SortField ("int", SortField.Type.INT), + new SortField ("string", SortField.Type.STRING), + new SortField ("float", SortField.Type.FLOAT) ); assertMatches (full, queryG, sort, "ZWXY"); // Reverse the last criterium to make sure the test didn't pass by chance - sort.setSort (new SortField ("int", SortField.INT), - new SortField ("string", SortField.STRING), - new SortField ("float", SortField.FLOAT, true) ); + sort.setSort (new SortField ("int", SortField.Type.INT), + new SortField ("string", SortField.Type.STRING), + new SortField ("float", SortField.Type.FLOAT, true) ); assertMatches (full, queryG, sort, "ZYXW"); // Do the same for a ParallelMultiSearcher ExecutorService exec = Executors.newFixedThreadPool(_TestUtil.nextInt(random, 2, 8)); IndexSearcher parallelSearcher=new IndexSearcher (full.getIndexReader(), exec); - sort.setSort (new SortField ("int", SortField.INT), - new SortField ("string", SortField.STRING), - new SortField ("float", SortField.FLOAT) ); + sort.setSort (new SortField ("int", SortField.Type.INT), + new SortField ("string", SortField.Type.STRING), + new SortField ("float", SortField.Type.FLOAT) ); assertMatches (parallelSearcher, queryG, sort, "ZWXY"); - sort.setSort (new SortField ("int", SortField.INT), - new SortField ("string", SortField.STRING), - new SortField ("float", SortField.FLOAT, true) ); + sort.setSort (new SortField ("int", SortField.Type.INT), + new SortField ("string", SortField.Type.STRING), + new SortField ("float", SortField.Type.FLOAT, true) ); assertMatches (parallelSearcher, queryG, sort, "ZYXW"); parallelSearcher.close(); exec.shutdown(); @@ -671,13 +671,13 @@ // test sorts using a series of fields public void testSortCombos() throws Exception { - sort.setSort (new SortField ("int", SortField.INT), new SortField ("float", SortField.FLOAT) ); + sort.setSort (new SortField ("int", SortField.Type.INT), new SortField ("float", SortField.Type.FLOAT) ); assertMatches (full, queryX, sort, "IGEAC"); - sort.setSort (new SortField ("int", SortField.INT, true), new SortField (null, SortField.DOC, true) ); + sort.setSort (new SortField ("int", SortField.Type.INT, true), new SortField (null, SortField.Type.DOC, true) ); assertMatches (full, queryX, sort, "CEAGI"); - sort.setSort (new SortField ("float", SortField.FLOAT), new SortField ("string", SortField.STRING) ); + sort.setSort (new SortField ("float", SortField.Type.FLOAT), new SortField ("string", SortField.Type.STRING) ); assertMatches (full, queryX, sort, "GICEA"); } @@ -940,88 +940,88 @@ String expected = isFull ? "ABCDEFGHIJ" : "ACEGIBDFHJ"; assertMatches(multi, queryA, sort, expected); - sort.setSort(new SortField ("int", SortField.INT)); + sort.setSort(new SortField ("int", SortField.Type.INT)); expected = isFull ? "IDHFGJABEC" : "IDHFGJAEBC"; assertMatches(multi, queryA, sort, expected); - sort.setSort(new SortField ("int", SortField.INT), SortField.FIELD_DOC); + sort.setSort(new SortField ("int", SortField.Type.INT), SortField.FIELD_DOC); expected = isFull ? "IDHFGJABEC" : "IDHFGJAEBC"; assertMatches(multi, queryA, sort, expected); - sort.setSort(new SortField("int", SortField.INT)); + sort.setSort(new SortField("int", SortField.Type.INT)); expected = isFull ? "IDHFGJABEC" : "IDHFGJAEBC"; assertMatches(multi, queryA, sort, expected); - sort.setSort(new SortField ("float", SortField.FLOAT), SortField.FIELD_DOC); + sort.setSort(new SortField ("float", SortField.Type.FLOAT), SortField.FIELD_DOC); assertMatches(multi, queryA, sort, "GDHJCIEFAB"); - sort.setSort(new SortField("float", SortField.FLOAT)); + sort.setSort(new SortField("float", SortField.Type.FLOAT)); assertMatches(multi, queryA, sort, "GDHJCIEFAB"); - sort.setSort(new SortField("string", SortField.STRING)); + sort.setSort(new SortField("string", SortField.Type.STRING)); assertMatches(multi, queryA, sort, "DJAIHGFEBC"); - sort.setSort(new SortField("int", SortField.INT, true)); + sort.setSort(new SortField("int", SortField.Type.INT, true)); expected = isFull ? "CABEJGFHDI" : "CAEBJGFHDI"; assertMatches(multi, queryA, sort, expected); - sort.setSort(new SortField("float", SortField.FLOAT, true)); + sort.setSort(new SortField("float", SortField.Type.FLOAT, true)); assertMatches(multi, queryA, sort, "BAFECIJHDG"); - sort.setSort(new SortField("string", SortField.STRING, true)); + sort.setSort(new SortField("string", SortField.Type.STRING, true)); assertMatches(multi, queryA, sort, "CBEFGHIAJD"); - sort.setSort(new SortField("int", SortField.INT),new SortField("float", SortField.FLOAT)); + sort.setSort(new SortField("int", SortField.Type.INT),new SortField("float", SortField.Type.FLOAT)); assertMatches(multi, queryA, sort, "IDHFGJEABC"); - sort.setSort(new SortField("float", SortField.FLOAT),new SortField("string", SortField.STRING)); + sort.setSort(new SortField("float", SortField.Type.FLOAT),new SortField("string", SortField.Type.STRING)); assertMatches(multi, queryA, sort, "GDHJICEFAB"); - sort.setSort(new SortField ("int", SortField.INT)); + sort.setSort(new SortField ("int", SortField.Type.INT)); assertMatches(multi, queryF, sort, "IZJ"); - sort.setSort(new SortField ("int", SortField.INT, true)); + sort.setSort(new SortField ("int", SortField.Type.INT, true)); assertMatches(multi, queryF, sort, "JZI"); - sort.setSort(new SortField ("float", SortField.FLOAT)); + sort.setSort(new SortField ("float", SortField.Type.FLOAT)); assertMatches(multi, queryF, sort, "ZJI"); - sort.setSort(new SortField ("string", SortField.STRING)); + sort.setSort(new SortField ("string", SortField.Type.STRING)); assertMatches(multi, queryF, sort, "ZJI"); - sort.setSort(new SortField ("string", SortField.STRING, true)); + sort.setSort(new SortField ("string", SortField.Type.STRING, true)); assertMatches(multi, queryF, sort, "IJZ"); if (supportsDocValues) { - sort.setSort(useDocValues(new SortField ("int", SortField.INT))); + sort.setSort(useDocValues(new SortField ("int", SortField.Type.INT))); expected = isFull ? "IDHFGJABEC" : "IDHFGJAEBC"; assertMatches(multi, queryA, sort, expected); - sort.setSort(useDocValues(new SortField ("int", SortField.INT)), SortField.FIELD_DOC); + sort.setSort(useDocValues(new SortField ("int", SortField.Type.INT)), SortField.FIELD_DOC); expected = isFull ? "IDHFGJABEC" : "IDHFGJAEBC"; assertMatches(multi, queryA, sort, expected); - sort.setSort(useDocValues(new SortField("int", SortField.INT))); + sort.setSort(useDocValues(new SortField("int", SortField.Type.INT))); expected = isFull ? "IDHFGJABEC" : "IDHFGJAEBC"; assertMatches(multi, queryA, sort, expected); - sort.setSort(useDocValues(new SortField ("float", SortField.FLOAT)), SortField.FIELD_DOC); + sort.setSort(useDocValues(new SortField ("float", SortField.Type.FLOAT)), SortField.FIELD_DOC); assertMatches(multi, queryA, sort, "GDHJCIEFAB"); - sort.setSort(useDocValues(new SortField("float", SortField.FLOAT))); + sort.setSort(useDocValues(new SortField("float", SortField.Type.FLOAT))); assertMatches(multi, queryA, sort, "GDHJCIEFAB"); - sort.setSort(useDocValues(new SortField("int", SortField.INT, true))); + sort.setSort(useDocValues(new SortField("int", SortField.Type.INT, true))); expected = isFull ? "CABEJGFHDI" : "CAEBJGFHDI"; assertMatches(multi, queryA, sort, expected); - sort.setSort(useDocValues(new SortField("int", SortField.INT)), useDocValues(new SortField("float", SortField.FLOAT))); + sort.setSort(useDocValues(new SortField("int", SortField.Type.INT)), useDocValues(new SortField("float", SortField.Type.FLOAT))); assertMatches(multi, queryA, sort, "IDHFGJEABC"); - sort.setSort(useDocValues(new SortField ("int", SortField.INT))); + sort.setSort(useDocValues(new SortField ("int", SortField.Type.INT))); assertMatches(multi, queryF, sort, "IZJ"); - sort.setSort(useDocValues(new SortField ("int", SortField.INT, true))); + sort.setSort(useDocValues(new SortField ("int", SortField.Type.INT, true))); assertMatches(multi, queryF, sort, "JZI"); } @@ -1071,7 +1071,7 @@ IndexReader r = IndexReader.open(w, true); w.close(); IndexSearcher s = newSearcher(r); - TopDocs hits = s.search(new TermQuery(new Term("t", "1")), null, 10, new Sort(new SortField("f", SortField.STRING))); + TopDocs hits = s.search(new TermQuery(new Term("t", "1")), null, 10, new Sort(new SortField("f", SortField.Type.STRING))); assertEquals(2, hits.totalHits); // null sorts first assertEquals(1, hits.scoreDocs[0].doc); @@ -1094,7 +1094,7 @@ writer.optimize(); // enforce one segment to have a higher unique term count in all cases writer.close(); sort.setSort( - new SortField("string", SortField.STRING), + new SortField("string", SortField.Type.STRING), SortField.FIELD_DOC ); // this should not throw AIOOBE or RuntimeEx IndexSearcher searcher = new IndexSearcher(indexStore, true); Index: lucene/src/test/org/apache/lucene/TestSearchForDuplicates.java =================================================================== --- lucene/src/test/org/apache/lucene/TestSearchForDuplicates.java (revision 1133599) +++ lucene/src/test/org/apache/lucene/TestSearchForDuplicates.java Mon Jun 20 20:27:59 NZST 2011 @@ -112,7 +112,7 @@ final Sort sort = new Sort(new SortField[] { SortField.FIELD_SCORE, - new SortField(ID_FIELD, SortField.INT)}); + new SortField(ID_FIELD, SortField.Type.INT)}); ScoreDoc[] hits = searcher.search(query, null, MAX_DOCS, sort).scoreDocs; printHits(out, hits, searcher); Index: lucene/src/test/org/apache/lucene/search/TestNumericRangeQuery64.java =================================================================== --- lucene/src/test/org/apache/lucene/search/TestNumericRangeQuery64.java (revision 1133616) +++ lucene/src/test/org/apache/lucene/search/TestNumericRangeQuery64.java Mon Jun 20 20:27:59 NZST 2011 @@ -530,7 +530,7 @@ long a=lower; lower=upper; upper=a; } Query tq=NumericRangeQuery.newLongRange(field, precisionStep, lower, upper, true, true); - TopDocs topDocs = searcher.search(tq, null, noDocs, new Sort(new SortField(field, SortField.LONG, true))); + TopDocs topDocs = searcher.search(tq, null, noDocs, new Sort(new SortField(field, SortField.Type.LONG, true))); if (topDocs.totalHits==0) continue; ScoreDoc[] sd = topDocs.scoreDocs; assertNotNull(sd); Index: lucene/src/java/org/apache/lucene/search/cache/IntValuesCreator.java =================================================================== --- lucene/src/java/org/apache/lucene/search/cache/IntValuesCreator.java (revision 1055409) +++ lucene/src/java/org/apache/lucene/search/cache/IntValuesCreator.java Tue Jun 21 01:33:55 NZST 2011 @@ -61,8 +61,8 @@ } @Override - public int getSortTypeID() { - return SortField.INT; + public SortField.Type getSortType() { + return SortField.Type.INT; } Index: lucene/src/test/org/apache/lucene/search/TestCustomSearcherSort.java =================================================================== --- lucene/src/test/org/apache/lucene/search/TestCustomSearcherSort.java (revision 1133616) +++ lucene/src/test/org/apache/lucene/search/TestCustomSearcherSort.java Mon Jun 20 20:27:59 NZST 2011 @@ -86,7 +86,7 @@ // log("Run testFieldSortCustomSearcher"); // define the sort criteria Sort custSort = new Sort( - new SortField("publicationDate_", SortField.STRING), + new SortField("publicationDate_", SortField.Type.STRING), SortField.FIELD_SCORE); IndexSearcher searcher = new CustomSearcher(reader, 2); // search and check hits @@ -100,7 +100,7 @@ // log("Run testFieldSortSingleSearcher"); // define the sort criteria Sort custSort = new Sort( - new SortField("publicationDate_", SortField.STRING), + new SortField("publicationDate_", SortField.Type.STRING), SortField.FIELD_SCORE); IndexSearcher searcher = new CustomSearcher(reader, 2); // search and check hits Index: modules/grouping/src/test/org/apache/lucene/search/grouping/TestGrouping.java =================================================================== --- modules/grouping/src/test/org/apache/lucene/search/grouping/TestGrouping.java (revision 1136605) +++ modules/grouping/src/test/org/apache/lucene/search/grouping/TestGrouping.java Tue Jun 21 02:20:29 NZST 2011 @@ -176,17 +176,17 @@ } else { if (random.nextBoolean()) { if (random.nextBoolean()) { - sortFields.add(new SortField("sort1", SortField.STRING, random.nextBoolean())); + sortFields.add(new SortField("sort1", SortField.Type.STRING, random.nextBoolean())); } else { - sortFields.add(new SortField("sort2", SortField.STRING, random.nextBoolean())); + sortFields.add(new SortField("sort2", SortField.Type.STRING, random.nextBoolean())); } } else if (random.nextBoolean()) { - sortFields.add(new SortField("sort1", SortField.STRING, random.nextBoolean())); - sortFields.add(new SortField("sort2", SortField.STRING, random.nextBoolean())); + sortFields.add(new SortField("sort1", SortField.Type.STRING, random.nextBoolean())); + sortFields.add(new SortField("sort2", SortField.Type.STRING, random.nextBoolean())); } } // Break ties: - sortFields.add(new SortField("id", SortField.INT)); + sortFields.add(new SortField("id", SortField.Type.INT)); return new Sort(sortFields.toArray(new SortField[sortFields.size()])); } @@ -197,7 +197,7 @@ public int compare(GroupDoc d1, GroupDoc d2) { for(SortField sf : sortFields) { final int cmp; - if (sf.getType() == SortField.SCORE) { + if (sf.getType() == SortField.Type.SCORE) { if (d1.score > d2.score) { cmp = -1; } else if (d1.score < d2.score) { @@ -230,7 +230,7 @@ for(int fieldIDX=0;fieldIDX c; final SortField sf = sortFields[fieldIDX]; - if (sf.getType() == SortField.SCORE) { + if (sf.getType() == SortField.Type.SCORE) { c = new Float(d.score); } else if (sf.getField().equals("sort1")) { c = d.sort1; @@ -625,13 +625,13 @@ final Sort docSort = getRandomSort(); for(SortField sf : docSort.getSort()) { - if (sf.getType() == SortField.SCORE) { + if (sf.getType() == SortField.Type.SCORE) { getScores = true; } } for(SortField sf : groupSort.getSort()) { - if (sf.getType() == SortField.SCORE) { + if (sf.getType() == SortField.Type.SCORE) { getScores = true; } } @@ -827,7 +827,7 @@ final SortField[] sortFields = groupSort.getSort(); final Map termScoreMap = scoreMap.get(searchTerm); for(int groupSortIDX=0;groupSortIDX