Index: contrib/highlighter/src/java/org/apache/lucene/search/highlight/WeightedSpanTermExtractor.java =================================================================== --- contrib/highlighter/src/java/org/apache/lucene/search/highlight/WeightedSpanTermExtractor.java (revision 827820) +++ contrib/highlighter/src/java/org/apache/lucene/search/highlight/WeightedSpanTermExtractor.java (working copy) @@ -47,7 +47,7 @@ private String fieldName; private TokenStream tokenStream; - private Map readers = new HashMap(10); // Map + private Map readers = new HashMap(10); private String defaultField; private boolean expandMultiTermQuery; private boolean cachedTokenStream; @@ -63,11 +63,9 @@ } private void closeReaders() { - Collection readerSet = readers.values(); - Iterator it = readerSet.iterator(); + Collection readerSet = readers.values(); - while (it.hasNext()) { - IndexReader reader = (IndexReader) it.next(); + for (final IndexReader reader : readerSet) { try { reader.close(); } catch (IOException e) { @@ -85,7 +83,7 @@ * Map to place created WeightedSpanTerms in * @throws IOException */ - private void extract(Query query, Map terms) throws IOException { + private void extract(Query query, Map terms) throws IOException { if (query instanceof BooleanQuery) { BooleanClause[] queryClauses = ((BooleanQuery) query).getClauses(); @@ -118,8 +116,8 @@ } else if (query instanceof FilteredQuery) { extract(((FilteredQuery) query).getQuery(), terms); } else if (query instanceof DisjunctionMaxQuery) { - for (Iterator iterator = ((DisjunctionMaxQuery) query).iterator(); iterator.hasNext();) { - extract((Query) iterator.next(), terms); + for (Iterator iterator = ((DisjunctionMaxQuery) query).iterator(); iterator.hasNext();) { + extract(iterator.next(), terms); } } else if (query instanceof MultiTermQuery && expandMultiTermQuery) { MultiTermQuery mtq = ((MultiTermQuery)query); @@ -144,7 +142,7 @@ } } else if (query instanceof MultiPhraseQuery) { final MultiPhraseQuery mpq = (MultiPhraseQuery) query; - final List termArrays = mpq.getTermArrays(); + final List termArrays = mpq.getTermArrays(); final int[] positions = mpq.getPositions(); if (positions.length > 0) { @@ -155,14 +153,14 @@ } } - final List[] disjunctLists = new List[maxPosition + 1]; + final List[] disjunctLists = new List[maxPosition + 1]; int distinctPositions = 0; for (int i = 0; i < termArrays.size(); ++i) { - final Term[] termArray = (Term[]) termArrays.get(i); - List disjuncts = disjunctLists[positions[i]]; + final Term[] termArray = termArrays.get(i); + List disjuncts = disjunctLists[positions[i]]; if (disjuncts == null) { - disjuncts = (disjunctLists[positions[i]] = new ArrayList(termArray.length)); + disjuncts = (disjunctLists[positions[i]] = new ArrayList(termArray.length)); ++distinctPositions; } for (int j = 0; j < termArray.length; ++j) { @@ -174,9 +172,9 @@ int position = 0; final SpanQuery[] clauses = new SpanQuery[distinctPositions]; for (int i = 0; i < disjunctLists.length; ++i) { - List disjuncts = disjunctLists[i]; + List disjuncts = disjunctLists[i]; if (disjuncts != null) { - clauses[position++] = new SpanOrQuery((SpanQuery[]) disjuncts + clauses[position++] = new SpanOrQuery(disjuncts .toArray(new SpanQuery[disjuncts.size()])); } else { ++positionGaps; @@ -202,20 +200,19 @@ * SpanQuery to extract Terms from * @throws IOException */ - private void extractWeightedSpanTerms(Map terms, SpanQuery spanQuery) throws IOException { - Set nonWeightedTerms = new HashSet(); + private void extractWeightedSpanTerms(Map terms, SpanQuery spanQuery) throws IOException { + Set nonWeightedTerms = new HashSet(); spanQuery.extractTerms(nonWeightedTerms); - Set fieldNames; + Set fieldNames; if (fieldName == null) { - fieldNames = new HashSet(); - for (Iterator iter = nonWeightedTerms.iterator(); iter.hasNext();) { - Term queryTerm = (Term) iter.next(); + fieldNames = new HashSet(); + for (final Term queryTerm : nonWeightedTerms) { fieldNames.add(queryTerm.field()); } } else { - fieldNames = new HashSet(1); + fieldNames = new HashSet(1); fieldNames.add(fieldName); } // To support the use of the default field name @@ -223,11 +220,9 @@ fieldNames.add(defaultField); } - Iterator it = fieldNames.iterator(); - List spanPositions = new ArrayList(); + List spanPositions = new ArrayList(); - while (it.hasNext()) { - String field = (String) it.next(); + for (final String field : fieldNames) { IndexReader reader = getReaderForField(field); Spans spans = spanQuery.getSpans(reader); @@ -244,11 +239,10 @@ return; } - for (Iterator iter = nonWeightedTerms.iterator(); iter.hasNext();) { - Term queryTerm = (Term) iter.next(); + for (final Term queryTerm : nonWeightedTerms) { if (fieldNameComparator(queryTerm.field())) { - WeightedSpanTerm weightedSpanTerm = (WeightedSpanTerm) terms.get(queryTerm.text()); + WeightedSpanTerm weightedSpanTerm = terms.get(queryTerm.text()); if (weightedSpanTerm == null) { weightedSpanTerm = new WeightedSpanTerm(spanQuery.getBoost(), queryTerm.text()); @@ -273,12 +267,11 @@ * Query to extract Terms from * @throws IOException */ - private void extractWeightedTerms(Map terms, Query query) throws IOException { - Set nonWeightedTerms = new HashSet(); + private void extractWeightedTerms(Map terms, Query query) throws IOException { + Set nonWeightedTerms = new HashSet(); query.extractTerms(nonWeightedTerms); - for (Iterator iter = nonWeightedTerms.iterator(); iter.hasNext();) { - Term queryTerm = (Term) iter.next(); + for (final Term queryTerm : nonWeightedTerms) { if (fieldNameComparator(queryTerm.field())) { WeightedSpanTerm weightedSpanTerm = new WeightedSpanTerm(query.getBoost(), queryTerm.text()); @@ -301,7 +294,7 @@ tokenStream = new CachingTokenFilter(tokenStream); cachedTokenStream = true; } - IndexReader reader = (IndexReader) readers.get(field); + IndexReader reader = readers.get(field); if (reader == null) { MemoryIndex indexer = new MemoryIndex(); indexer.addField(field, tokenStream); @@ -326,7 +319,7 @@ * @return Map containing WeightedSpanTerms * @throws IOException */ - public Map getWeightedSpanTerms(Query query, TokenStream tokenStream) + public Map getWeightedSpanTerms(Query query, TokenStream tokenStream) throws IOException { return getWeightedSpanTerms(query, tokenStream, null); } @@ -345,7 +338,7 @@ * @return Map containing WeightedSpanTerms * @throws IOException */ - public Map getWeightedSpanTerms(Query query, TokenStream tokenStream, + public Map getWeightedSpanTerms(Query query, TokenStream tokenStream, String fieldName) throws IOException { if (fieldName != null) { this.fieldName = StringHelper.intern(fieldName); @@ -353,7 +346,7 @@ this.fieldName = null; } - Map terms = new PositionCheckingMap(); + Map terms = new PositionCheckingMap(); this.tokenStream = tokenStream; try { extract(query, terms); @@ -381,7 +374,7 @@ * @return Map of WeightedSpanTerms with quasi tf/idf scores * @throws IOException */ - public Map getWeightedSpanTermsWithScores(Query query, TokenStream tokenStream, String fieldName, + public Map getWeightedSpanTermsWithScores(Query query, TokenStream tokenStream, String fieldName, IndexReader reader) throws IOException { if (fieldName != null) { this.fieldName = StringHelper.intern(fieldName); @@ -390,16 +383,16 @@ } this.tokenStream = tokenStream; - Map terms = new PositionCheckingMap(); + Map terms = new PositionCheckingMap(); extract(query, terms); int totalNumDocs = reader.numDocs(); - Set weightedTerms = terms.keySet(); - Iterator it = weightedTerms.iterator(); + Set weightedTerms = terms.keySet(); + Iterator it = weightedTerms.iterator(); try { while (it.hasNext()) { - WeightedSpanTerm weightedSpanTerm = (WeightedSpanTerm) terms.get(it.next()); + WeightedSpanTerm weightedSpanTerm = terms.get(it.next()); int docFreq = reader.docFreq(new Term(fieldName, weightedSpanTerm.term)); // docFreq counts deletes if(totalNumDocs < docFreq) { @@ -421,21 +414,21 @@ * This class makes sure that if both position sensitive and insensitive * versions of the same term are added, the position insensitive one wins. */ - static private class PositionCheckingMap extends HashMap { + static private class PositionCheckingMap extends HashMap { public void putAll(Map m) { - Iterator it = m.entrySet().iterator(); + Iterator> it = m.entrySet().iterator(); while (it.hasNext()) { - Map.Entry entry = (java.util.Map.Entry) it.next(); + Map.Entry entry = it.next(); this.put(entry.getKey(), entry.getValue()); } } - public Object put(Object key, Object value) { - Object prev = super.put(key, value); + public WeightedSpanTerm put(K key, WeightedSpanTerm value) { + WeightedSpanTerm prev = super.put(key, value); if (prev == null) return prev; - WeightedSpanTerm prevTerm = (WeightedSpanTerm)prev; - WeightedSpanTerm newTerm = (WeightedSpanTerm)value; + WeightedSpanTerm prevTerm = prev; + WeightedSpanTerm newTerm = value; if (!prevTerm.positionSensitive) { newTerm.positionSensitive = false; } Index: contrib/highlighter/src/java/org/apache/lucene/search/highlight/WeightedSpanTerm.java =================================================================== --- contrib/highlighter/src/java/org/apache/lucene/search/highlight/WeightedSpanTerm.java (revision 827820) +++ contrib/highlighter/src/java/org/apache/lucene/search/highlight/WeightedSpanTerm.java (working copy) @@ -28,7 +28,7 @@ */ public class WeightedSpanTerm extends WeightedTerm{ boolean positionSensitive; - private List positionSpans = new ArrayList(); + private List positionSpans = new ArrayList(); /** * @param weight @@ -36,7 +36,7 @@ */ public WeightedSpanTerm(float weight, String term) { super(weight, term); - this.positionSpans = new ArrayList(); + this.positionSpans = new ArrayList(); } /** @@ -61,10 +61,10 @@ // where kept in some sort of priority queue - that way this method // could // bail early without checking each PositionSpan. - Iterator positionSpanIt = positionSpans.iterator(); + Iterator positionSpanIt = positionSpans.iterator(); while (positionSpanIt.hasNext()) { - PositionSpan posSpan = (PositionSpan) positionSpanIt.next(); + PositionSpan posSpan = positionSpanIt.next(); if (((position >= posSpan.start) && (position <= posSpan.end))) { return true; @@ -74,7 +74,7 @@ return false; } - public void addPositionSpans(List positionSpans) { + public void addPositionSpans(List positionSpans) { this.positionSpans.addAll(positionSpans); } @@ -86,7 +86,7 @@ this.positionSensitive = positionSensitive; } - public List getPositionSpans() { + public List getPositionSpans() { return positionSpans; } } Index: contrib/highlighter/src/java/org/apache/lucene/search/highlight/QueryTermScorer.java =================================================================== --- contrib/highlighter/src/java/org/apache/lucene/search/highlight/QueryTermScorer.java (revision 827820) +++ contrib/highlighter/src/java/org/apache/lucene/search/highlight/QueryTermScorer.java (working copy) @@ -35,11 +35,11 @@ public class QueryTermScorer implements Scorer { TextFragment currentTextFragment = null; - HashSet uniqueTermsInFragment; + HashSet uniqueTermsInFragment; float totalScore = 0; float maxTermWeight = 0; - private HashMap termsToFind; + private HashMap termsToFind; private TermAttribute termAtt; @@ -77,9 +77,9 @@ } public QueryTermScorer(WeightedTerm[] weightedTerms) { - termsToFind = new HashMap(); + termsToFind = new HashMap(); for (int i = 0; i < weightedTerms.length; i++) { - WeightedTerm existingTerm = (WeightedTerm) termsToFind + WeightedTerm existingTerm = termsToFind .get(weightedTerms[i].term); if ((existingTerm == null) || (existingTerm.weight < weightedTerms[i].weight)) { @@ -107,7 +107,7 @@ * .lucene.search.highlight.TextFragment) */ public void startFragment(TextFragment newFragment) { - uniqueTermsInFragment = new HashSet(); + uniqueTermsInFragment = new HashSet(); currentTextFragment = newFragment; totalScore = 0; @@ -120,7 +120,7 @@ public float getTokenScore() { String termText = termAtt.term(); - WeightedTerm queryTerm = (WeightedTerm) termsToFind.get(termText); + WeightedTerm queryTerm = termsToFind.get(termText); if (queryTerm == null) { // not a query term - return return 0; Index: contrib/highlighter/src/java/org/apache/lucene/search/highlight/QueryScorer.java =================================================================== --- contrib/highlighter/src/java/org/apache/lucene/search/highlight/QueryScorer.java (revision 827820) +++ contrib/highlighter/src/java/org/apache/lucene/search/highlight/QueryScorer.java (working copy) @@ -41,8 +41,8 @@ */ public class QueryScorer implements Scorer { private float totalScore; - private Set foundTerms; - private Map fieldWeightedSpanTerms; + private Set foundTerms; + private Map fieldWeightedSpanTerms; private float maxTermWeight; private int position = -1; private String defaultField; @@ -103,10 +103,10 @@ * @param weightedTerms an array of pre-created {@link WeightedSpanTerm}s */ public QueryScorer(WeightedSpanTerm[] weightedTerms) { - this.fieldWeightedSpanTerms = new HashMap(weightedTerms.length); + this.fieldWeightedSpanTerms = new HashMap(weightedTerms.length); for (int i = 0; i < weightedTerms.length; i++) { - WeightedSpanTerm existingTerm = (WeightedSpanTerm) fieldWeightedSpanTerms.get(weightedTerms[i].term); + WeightedSpanTerm existingTerm = fieldWeightedSpanTerms.get(weightedTerms[i].term); if ((existingTerm == null) || (existingTerm.weight < weightedTerms[i].weight)) { @@ -149,7 +149,7 @@ WeightedSpanTerm weightedSpanTerm; - if ((weightedSpanTerm = (WeightedSpanTerm) fieldWeightedSpanTerms.get( + if ((weightedSpanTerm = fieldWeightedSpanTerms.get( termText)) == null) { return 0; } @@ -194,7 +194,7 @@ * @return WeightedSpanTerm for token */ public WeightedSpanTerm getWeightedSpanTerm(String token) { - return (WeightedSpanTerm) fieldWeightedSpanTerms.get(token); + return fieldWeightedSpanTerms.get(token); } /** @@ -232,7 +232,7 @@ * @see org.apache.lucene.search.highlight.Scorer#startFragment(org.apache.lucene.search.highlight.TextFragment) */ public void startFragment(TextFragment newFragment) { - foundTerms = new HashSet(); + foundTerms = new HashSet(); totalScore = 0; } Index: contrib/highlighter/src/java/org/apache/lucene/search/highlight/TokenSources.java =================================================================== --- contrib/highlighter/src/java/org/apache/lucene/search/highlight/TokenSources.java (revision 827820) +++ contrib/highlighter/src/java/org/apache/lucene/search/highlight/TokenSources.java (working copy) @@ -59,7 +59,7 @@ public static TokenStream getAnyTokenStream(IndexReader reader, int docId, String field, Document doc, Analyzer analyzer) throws IOException{ TokenStream ts=null; - TermFreqVector tfv=(TermFreqVector) reader.getTermFreqVector(docId,field); + TermFreqVector tfv= reader.getTermFreqVector(docId,field); if(tfv!=null) { if(tfv instanceof TermPositionVector) @@ -89,7 +89,7 @@ { TokenStream ts=null; - TermFreqVector tfv=(TermFreqVector) reader.getTermFreqVector(docId,field); + TermFreqVector tfv= reader.getTermFreqVector(docId,field); if(tfv!=null) { if(tfv instanceof TermPositionVector) @@ -171,7 +171,7 @@ totalTokens+=freq[t]; } Token tokensInOriginalOrder[]=new Token[totalTokens]; - ArrayList unsortedTokens = null; + ArrayList unsortedTokens = null; for (int t = 0; t < freq.length; t++) { TermVectorOffsetInfo[] offsets=tpv.getOffsets(t); @@ -191,7 +191,7 @@ //tokens NOT stored with positions or not guaranteed contiguous - must add to list and sort later if(unsortedTokens==null) { - unsortedTokens=new ArrayList(); + unsortedTokens=new ArrayList(); } for (int tp = 0; tp < offsets.length; tp++) { @@ -218,12 +218,10 @@ //If the field has been stored without position data we must perform a sort if(unsortedTokens!=null) { - tokensInOriginalOrder=(Token[]) unsortedTokens.toArray(new Token[unsortedTokens.size()]); - Arrays.sort(tokensInOriginalOrder, new Comparator(){ - public int compare(Object o1, Object o2) + tokensInOriginalOrder= unsortedTokens.toArray(new Token[unsortedTokens.size()]); + Arrays.sort(tokensInOriginalOrder, new Comparator(){ + public int compare(Token t1, Token t2) { - Token t1=(Token) o1; - Token t2=(Token) o2; if(t1.startOffset()>t2.endOffset()) return 1; if(t1.startOffset() positionSpans = wSpanTerm.getPositionSpans(); for (int i = 0; i < positionSpans.size(); i++) { - if (((PositionSpan) positionSpans.get(i)).start == position) { - waitForPos = ((PositionSpan) positionSpans.get(i)).end + 1; + if (positionSpans.get(i).start == position) { + waitForPos = positionSpans.get(i).end + 1; break; } } Index: contrib/highlighter/src/java/org/apache/lucene/search/highlight/QueryTermExtractor.java =================================================================== --- contrib/highlighter/src/java/org/apache/lucene/search/highlight/QueryTermExtractor.java (revision 827820) +++ contrib/highlighter/src/java/org/apache/lucene/search/highlight/QueryTermExtractor.java (working copy) @@ -93,13 +93,13 @@ */ public static final WeightedTerm[] getTerms(Query query, boolean prohibited, String fieldName) { - HashSet terms=new HashSet(); + HashSet terms=new HashSet(); if(fieldName!=null) { fieldName= StringHelper.intern(fieldName); } getTerms(query,terms,prohibited,fieldName); - return (WeightedTerm[]) terms.toArray(new WeightedTerm[0]); + return terms.toArray(new WeightedTerm[0]); } /** @@ -115,7 +115,7 @@ } //fieldname MUST be interned prior to this call - private static final void getTerms(Query query, HashSet terms,boolean prohibited, String fieldName) + private static final void getTerms(Query query, HashSet terms,boolean prohibited, String fieldName) { try { @@ -126,11 +126,11 @@ getTermsFromFilteredQuery((FilteredQuery)query, terms,prohibited, fieldName); else { - HashSet nonWeightedTerms=new HashSet(); + HashSet nonWeightedTerms=new HashSet(); query.extractTerms(nonWeightedTerms); - for (Iterator iter = nonWeightedTerms.iterator(); iter.hasNext();) + for (Iterator iter = nonWeightedTerms.iterator(); iter.hasNext();) { - Term term = (Term) iter.next(); + Term term = iter.next(); if((fieldName==null)||(term.field()==fieldName)) { terms.add(new WeightedTerm(query.getBoost(),term.text())); @@ -155,7 +155,7 @@ * something common which would allow access to child queries so what follows here are query-specific * implementations for accessing embedded query elements. */ - private static final void getTermsFromBooleanQuery(BooleanQuery query, HashSet terms, boolean prohibited, String fieldName) + private static final void getTermsFromBooleanQuery(BooleanQuery query, HashSet terms, boolean prohibited, String fieldName) { BooleanClause[] queryClauses = query.getClauses(); for (int i = 0; i < queryClauses.length; i++) @@ -164,7 +164,7 @@ getTerms(queryClauses[i].getQuery(), terms, prohibited, fieldName); } } - private static void getTermsFromFilteredQuery(FilteredQuery query, HashSet terms, boolean prohibited, String fieldName) + private static void getTermsFromFilteredQuery(FilteredQuery query, HashSet terms, boolean prohibited, String fieldName) { getTerms(query.getQuery(),terms,prohibited,fieldName); } Index: contrib/highlighter/src/java/org/apache/lucene/search/highlight/Highlighter.java =================================================================== --- contrib/highlighter/src/java/org/apache/lucene/search/highlight/Highlighter.java (revision 827820) +++ contrib/highlighter/src/java/org/apache/lucene/search/highlight/Highlighter.java (working copy) @@ -184,7 +184,7 @@ TextFragment[] frag =getBestTextFragments(tokenStream,text, true,maxNumFragments); //Get text - ArrayList fragTexts = new ArrayList(); + ArrayList fragTexts = new ArrayList(); for (int i = 0; i < frag.length; i++) { if ((frag[i] != null) && (frag[i].getScore() > 0)) @@ -192,7 +192,7 @@ fragTexts.add(frag[i].toString()); } } - return (String[]) fragTexts.toArray(new String[0]); + return fragTexts.toArray(new String[0]); } @@ -214,7 +214,7 @@ int maxNumFragments) throws IOException, InvalidTokenOffsetsException { - ArrayList docFrags = new ArrayList(); + ArrayList docFrags = new ArrayList(); StringBuilder newText=new StringBuilder(); TermAttribute termAtt = tokenStream.addAttribute(TermAttribute.class); @@ -320,9 +320,9 @@ currentFrag.textEndPos = newText.length(); //sort the most relevant sections of the text - for (Iterator i = docFrags.iterator(); i.hasNext();) + for (Iterator i = docFrags.iterator(); i.hasNext();) { - currentFrag = (TextFragment) i.next(); + currentFrag = i.next(); //If you are running with a version of Lucene before 11th Sept 03 // you do not have PriorityQueue.insert() - so uncomment the code below @@ -349,14 +349,14 @@ TextFragment frag[] = new TextFragment[fragQueue.size()]; for (int i = frag.length - 1; i >= 0; i--) { - frag[i] = (TextFragment) fragQueue.pop(); + frag[i] = fragQueue.pop(); } //merge any contiguous fragments to improve readability if(mergeContiguousFragments) { mergeContiguousFragments(frag); - ArrayList fragTexts = new ArrayList(); + ArrayList fragTexts = new ArrayList(); for (int i = 0; i < frag.length; i++) { if ((frag[i] != null) && (frag[i].getScore() > 0)) @@ -364,7 +364,7 @@ fragTexts.add(frag[i]); } } - frag= (TextFragment[]) fragTexts.toArray(new TextFragment[0]); + frag= fragTexts.toArray(new TextFragment[0]); } return frag; @@ -567,17 +567,15 @@ this.encoder = encoder; } } -class FragmentQueue extends PriorityQueue +class FragmentQueue extends PriorityQueue { public FragmentQueue(int size) { initialize(size); } - public final boolean lessThan(Object a, Object b) + public final boolean lessThan(TextFragment fragA, TextFragment fragB) { - TextFragment fragA = (TextFragment) a; - TextFragment fragB = (TextFragment) b; if (fragA.getScore() == fragB.getScore()) return fragA.fragNum > fragB.fragNum; else