lucene-java-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From uschind...@apache.org
Subject svn commit: r830790 - in /lucene/java/trunk/contrib: benchmark/src/java/org/apache/lucene/benchmark/byTask/utils/ memory/src/java/org/apache/lucene/index/memory/ misc/src/java/org/apache/lucene/index/ misc/src/java/org/apache/lucene/misc/ misc/src/java...
Date Wed, 28 Oct 2009 23:21:26 GMT
Author: uschindler
Date: Wed Oct 28 23:21:25 2009
New Revision: 830790

URL: http://svn.apache.org/viewvc?rev=830790&view=rev
Log:
LUCENE-1257: Generics in contrib/memory, contrib/wordnet (previously memory), contrib/misc, contrib/benchmark

Modified:
    lucene/java/trunk/contrib/benchmark/src/java/org/apache/lucene/benchmark/byTask/utils/Config.java
    lucene/java/trunk/contrib/memory/src/java/org/apache/lucene/index/memory/MemoryIndex.java
    lucene/java/trunk/contrib/memory/src/java/org/apache/lucene/index/memory/PatternAnalyzer.java
    lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/index/BalancedSegmentMergePolicy.java
    lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/index/FieldNormModifier.java
    lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/index/IndexSplitter.java
    lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/index/MultiPassIndexSplitter.java
    lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/index/TermVectorAccessor.java
    lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/misc/HighFreqTerms.java
    lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/misc/LengthNormModifier.java
    lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/misc/SweetSpotSimilarity.java
    lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/queryParser/analyzing/AnalyzingQueryParser.java
    lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/queryParser/complexPhrase/ComplexPhraseQueryParser.java
    lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/queryParser/precedence/FastCharStream.java
    lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/queryParser/precedence/PrecedenceQueryParser.java
    lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/queryParser/precedence/PrecedenceQueryParser.jj
    lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/queryParser/precedence/PrecedenceQueryParserTokenManager.java
    lucene/java/trunk/contrib/wordnet/src/java/org/apache/lucene/wordnet/AnalyzerUtil.java
    lucene/java/trunk/contrib/wordnet/src/java/org/apache/lucene/wordnet/SynonymMap.java

Modified: lucene/java/trunk/contrib/benchmark/src/java/org/apache/lucene/benchmark/byTask/utils/Config.java
URL: http://svn.apache.org/viewvc/lucene/java/trunk/contrib/benchmark/src/java/org/apache/lucene/benchmark/byTask/utils/Config.java?rev=830790&r1=830789&r2=830790&view=diff
==============================================================================
--- lucene/java/trunk/contrib/benchmark/src/java/org/apache/lucene/benchmark/byTask/utils/Config.java (original)
+++ lucene/java/trunk/contrib/benchmark/src/java/org/apache/lucene/benchmark/byTask/utils/Config.java Wed Oct 28 23:21:25 2009
@@ -25,8 +25,6 @@
 import java.util.List;
 import java.util.Collections;
 import java.util.HashMap;
-import java.util.Iterator;
-import java.util.Map;
 import java.util.Properties;
 import java.util.StringTokenizer;
 
@@ -50,7 +48,7 @@
 
   private int roundNumber = 0;
   private Properties props;
-  private HashMap valByRound = new HashMap();
+  private HashMap<String,Object> valByRound = new HashMap<String,Object>();
   private HashMap<String,String> colForValByRound = new HashMap<String,String>();
   private String algorithmText;
 
@@ -247,8 +245,7 @@
     // log changes in values
     if (valByRound.size()>0) {
       sb.append(": ");
-      for (Iterator iter = valByRound.keySet().iterator(); iter.hasNext();) {
-        String name = (String) iter.next();
+      for (final String name : valByRound.keySet()) {
         Object a = valByRound.get(name);
         if (a instanceof int[]) {
           int ai[] = (int[]) a;

Modified: lucene/java/trunk/contrib/memory/src/java/org/apache/lucene/index/memory/MemoryIndex.java
URL: http://svn.apache.org/viewvc/lucene/java/trunk/contrib/memory/src/java/org/apache/lucene/index/memory/MemoryIndex.java?rev=830790&r1=830789&r2=830790&view=diff
==============================================================================
--- lucene/java/trunk/contrib/memory/src/java/org/apache/lucene/index/memory/MemoryIndex.java (original)
+++ lucene/java/trunk/contrib/memory/src/java/org/apache/lucene/index/memory/MemoryIndex.java Wed Oct 28 23:21:25 2009
@@ -175,10 +175,10 @@
 public class MemoryIndex implements Serializable {
 
   /** info for each field: Map<String fieldName, Info field> */
-  private final HashMap fields = new HashMap();
+  private final HashMap<String,Info> fields = new HashMap<String,Info>();
   
   /** fields sorted ascending by fieldName; lazily computed on demand */
-  private transient Map.Entry[] sortedFields; 
+  private transient Map.Entry<String,Info>[] sortedFields; 
   
   /** pos: positions[3*i], startOffset: positions[3*i +1], endOffset: positions[3*i +2] */
   private final int stride;
@@ -270,13 +270,13 @@
    *            the keywords to generate tokens for
    * @return the corresponding token stream
    */
-  public TokenStream keywordTokenStream(final Collection keywords) {
+  public <T> TokenStream keywordTokenStream(final Collection<T> keywords) {
     // TODO: deprecate & move this method into AnalyzerUtil?
     if (keywords == null)
       throw new IllegalArgumentException("keywords must not be null");
     
     return new TokenStream() {
-      private Iterator iter = keywords.iterator();
+      private Iterator<T> iter = keywords.iterator();
       private int start = 0;
       private TermAttribute termAtt = addAttribute(TermAttribute.class);
       private OffsetAttribute offsetAtt = addAttribute(OffsetAttribute.class);
@@ -284,7 +284,7 @@
       public boolean incrementToken() {
         if (!iter.hasNext()) return false;
         
-        Object obj = iter.next();
+        T obj = iter.next();
         if (obj == null) 
           throw new IllegalArgumentException("keyword must not be null");
         
@@ -335,7 +335,7 @@
       if (fields.get(fieldName) != null)
         throw new IllegalArgumentException("field must not be added more than once");
       
-      HashMap terms = new HashMap();
+      HashMap<String,ArrayIntList> terms = new HashMap<String,ArrayIntList>();
       int numTokens = 0;
       int numOverlapTokens = 0;
       int pos = -1;
@@ -355,7 +355,7 @@
           numOverlapTokens++;
         pos += posIncr;
         
-        ArrayIntList positions = (ArrayIntList) terms.get(term);
+        ArrayIntList positions = terms.get(term);
         if (positions == null) { // term not seen before
           positions = new ArrayIntList(stride);
           terms.put(term, positions);
@@ -471,21 +471,19 @@
     if (sortedFields != null) size += VM.sizeOfObjectArray(sortedFields.length);
     
     size += VM.sizeOfHashMap(fields.size());
-    Iterator iter = fields.entrySet().iterator();
-    while (iter.hasNext()) { // for each Field Info
-      Map.Entry entry = (Map.Entry) iter.next();      
-      Info info = (Info) entry.getValue();
+    for (Map.Entry<String, Info> entry : fields.entrySet()) { // for each Field Info
+      Info info = entry.getValue();
       size += VM.sizeOfObject(2*INT + 3*PTR); // Info instance vars
       if (info.sortedTerms != null) size += VM.sizeOfObjectArray(info.sortedTerms.length);
       
       int len = info.terms.size();
       size += VM.sizeOfHashMap(len);
-      Iterator iter2 = info.terms.entrySet().iterator();
+      Iterator<Map.Entry<String,ArrayIntList>> iter2 = info.terms.entrySet().iterator();
       while (--len >= 0) { // for each term
-        Map.Entry e = (Map.Entry) iter2.next();
+        Map.Entry<String,ArrayIntList> e = iter2.next();
         size += VM.sizeOfObject(PTR + 3*INT); // assumes substring() memory overlay
 //        size += STR + 2 * ((String) e.getKey()).length();
-        ArrayIntList positions = (ArrayIntList) e.getValue();
+        ArrayIntList positions = e.getValue();
         size += VM.sizeOfArrayIntList(positions.size());
       }
     }
@@ -502,13 +500,13 @@
   }
   
   /** returns a view of the given map's entries, sorted ascending by key */
-  private static Map.Entry[] sort(HashMap map) {
+  private static <K,V> Map.Entry<K,V>[] sort(HashMap<K,V> map) {
     int size = map.size();
-    Map.Entry[] entries = new Map.Entry[size];
+    Map.Entry<K,V>[] entries = new Map.Entry[size];
     
-    Iterator iter = map.entrySet().iterator();
+    Iterator<Map.Entry<K,V>> iter = map.entrySet().iterator();
     for (int i=0; i < size; i++) {
-      entries[i] = (Map.Entry) iter.next();
+      entries[i] = iter.next();
     }
     
     if (size > 1) Arrays.sort(entries, termComparator);
@@ -528,18 +526,18 @@
     int sumTerms = 0;
     
     for (int i=0; i < sortedFields.length; i++) {
-      Map.Entry entry = sortedFields[i];
-      String fieldName = (String) entry.getKey();
-      Info info = (Info) entry.getValue();
+      Map.Entry<String,Info> entry = sortedFields[i];
+      String fieldName = entry.getKey();
+      Info info = entry.getValue();
       info.sortTerms();
       result.append(fieldName + ":\n");
       
       int numChars = 0;
       int numPositions = 0;
       for (int j=0; j < info.sortedTerms.length; j++) {
-        Map.Entry e = info.sortedTerms[j];
-        String term = (String) e.getKey();
-        ArrayIntList positions = (ArrayIntList) e.getValue();
+        Map.Entry<String,ArrayIntList> e = info.sortedTerms[j];
+        String term = e.getKey();
+        ArrayIntList positions = e.getValue();
         result.append("\t'" + term + "':" + numPositions(positions) + ":");
         result.append(positions.toString(stride)); // ignore offsets
         result.append("\n");
@@ -577,10 +575,10 @@
      * Term strings and their positions for this field: Map <String
      * termText, ArrayIntList positions>
      */
-    private final HashMap terms; 
+    private final HashMap<String,ArrayIntList> terms; 
     
     /** Terms sorted ascending by term text; computed on demand */
-    private transient Map.Entry[] sortedTerms;
+    private transient Map.Entry<String,ArrayIntList>[] sortedTerms;
     
     /** Number of added tokens for this field */
     private final int numTokens;
@@ -596,7 +594,7 @@
 
     private static final long serialVersionUID = 2882195016849084649L;  
 
-    public Info(HashMap terms, int numTokens, int numOverlapTokens, float boost) {
+    public Info(HashMap<String,ArrayIntList> terms, int numTokens, int numOverlapTokens, float boost) {
       this.terms = terms;
       this.numTokens = numTokens;
       this.numOverlapTokens = numOverlapTokens;
@@ -617,12 +615,12 @@
         
     /** note that the frequency can be calculated as numPosition(getPositions(x)) */
     public ArrayIntList getPositions(String term) {
-      return (ArrayIntList) terms.get(term);
+      return terms.get(term);
     }
 
     /** note that the frequency can be calculated as numPosition(getPositions(x)) */
     public ArrayIntList getPositions(int pos) {
-      return (ArrayIntList) sortedTerms[pos].getValue();
+      return sortedTerms[pos].getValue();
     }
     
     public float getBoost() {
@@ -736,11 +734,11 @@
     protected void finalize() {}
     
     private Info getInfo(String fieldName) {
-      return (Info) fields.get(fieldName);
+      return fields.get(fieldName);
     }
     
     private Info getInfo(int pos) {
-      return (Info) sortedFields[pos].getValue();
+      return sortedFields[pos].getValue();
     }
     
     public int docFreq(Term term) {
@@ -814,7 +812,7 @@
           Info info = getInfo(j);
           if (i >= info.sortedTerms.length) return null;
 //          if (DEBUG) System.err.println("TermEnum.term: " + i + ", " + info.sortedTerms[i].getKey());
-          return createTerm(info, j, (String) info.sortedTerms[i].getKey());
+          return createTerm(info, j, info.sortedTerms[i].getKey());
         }
         
         public int docFreq() {
@@ -834,7 +832,7 @@
           // Assertion: sortFields has already been called before
           Term template = info.template;
           if (template == null) { // not yet cached?
-            String fieldName = (String) sortedFields[pos].getKey();
+            String fieldName = sortedFields[pos].getKey();
             template = new Term(fieldName);
             info.template = template;
           }
@@ -949,10 +947,9 @@
       if (DEBUG) System.err.println("MemoryIndexReader.getTermFreqVectors");
       TermFreqVector[] vectors = new TermFreqVector[fields.size()];
 //      if (vectors.length == 0) return null;
-      Iterator iter = fields.keySet().iterator();
+      Iterator<String> iter = fields.keySet().iterator();
       for (int i=0; i < vectors.length; i++) {
-        String fieldName = (String) iter.next();
-        vectors[i] = getTermFreqVector(docNumber, fieldName);
+        vectors[i] = getTermFreqVector(docNumber, iter.next());
       }
       return vectors;
     }
@@ -962,9 +959,8 @@
           if (DEBUG) System.err.println("MemoryIndexReader.getTermFreqVectors");
 
     //      if (vectors.length == 0) return null;
-          for (Iterator iterator = fields.keySet().iterator(); iterator.hasNext();)
+          for (final String fieldName : fields.keySet())
           {
-            String fieldName = (String) iterator.next();
             getTermFreqVector(docNumber, fieldName, mapper);
           }
       }
@@ -980,7 +976,7 @@
           mapper.setExpectations(field, info.sortedTerms.length, stride != 1, true);
           for (int i = info.sortedTerms.length; --i >=0;){
 
-              ArrayIntList positions = (ArrayIntList) info.sortedTerms[i].getValue();
+              ArrayIntList positions = info.sortedTerms[i].getValue();
               int size = positions.size();
               org.apache.lucene.index.TermVectorOffsetInfo[] offsets =
                 new org.apache.lucene.index.TermVectorOffsetInfo[size / stride];
@@ -990,9 +986,9 @@
                 int end = positions.get(j+1);
                 offsets[k] = new org.apache.lucene.index.TermVectorOffsetInfo(start, end);
               }
-              mapper.map((String)info.sortedTerms[i].getKey(),
-                         numPositions((ArrayIntList) info.sortedTerms[i].getValue()),
-                         offsets, ((ArrayIntList) info.sortedTerms[i].getValue()).toArray(stride));
+              mapper.map(info.sortedTerms[i].getKey(),
+                         numPositions(info.sortedTerms[i].getValue()),
+                         offsets, (info.sortedTerms[i].getValue()).toArray(stride));
           }
       }
 
@@ -1004,7 +1000,7 @@
       
       return new TermPositionVector() { 
   
-        private final Map.Entry[] sortedTerms = info.sortedTerms;
+        private final Map.Entry<String,ArrayIntList>[] sortedTerms = info.sortedTerms;
         
         public String getField() {
           return fieldName;
@@ -1017,7 +1013,7 @@
         public String[] getTerms() {
           String[] terms = new String[sortedTerms.length];
           for (int i=sortedTerms.length; --i >= 0; ) {
-            terms[i] = (String) sortedTerms[i].getKey();
+            terms[i] = sortedTerms[i].getKey();
           }
           return terms;
         }
@@ -1025,7 +1021,7 @@
         public int[] getTermFrequencies() {
           int[] freqs = new int[sortedTerms.length];
           for (int i=sortedTerms.length; --i >= 0; ) {
-            freqs[i] = numPositions((ArrayIntList) sortedTerms[i].getValue());
+            freqs[i] = numPositions(sortedTerms[i].getValue());
           }
           return freqs;
         }
@@ -1045,14 +1041,14 @@
         
         // lucene >= 1.4.3
         public int[] getTermPositions(int index) {
-          return ((ArrayIntList) sortedTerms[index].getValue()).toArray(stride);
+          return sortedTerms[index].getValue().toArray(stride);
         } 
         
         // lucene >= 1.9 (remove this method for lucene-1.4.3)
         public org.apache.lucene.index.TermVectorOffsetInfo[] getOffsets(int index) {
           if (stride == 1) return null; // no offsets stored
           
-          ArrayIntList positions = (ArrayIntList) sortedTerms[index].getValue();
+          ArrayIntList positions = sortedTerms[index].getValue();
           int size = positions.size();
           org.apache.lucene.index.TermVectorOffsetInfo[] offsets = 
             new org.apache.lucene.index.TermVectorOffsetInfo[size / stride];
@@ -1153,7 +1149,7 @@
       throw new UnsupportedOperationException();
     }
   
-    protected void doCommit(Map commitUserData) {
+    protected void doCommit(Map<String,String> commitUserData) {
       if (DEBUG) System.err.println("MemoryIndexReader.doCommit");
     }
   
@@ -1162,16 +1158,16 @@
     }
     
     // lucene >= 1.9 (remove this method for lucene-1.4.3)
-    public Collection getFieldNames(FieldOption fieldOption) {
+    public Collection<String> getFieldNames(FieldOption fieldOption) {
       if (DEBUG) System.err.println("MemoryIndexReader.getFieldNamesOption");
       if (fieldOption == FieldOption.UNINDEXED) 
-        return Collections.EMPTY_SET;
+        return Collections.<String>emptySet();
       if (fieldOption == FieldOption.INDEXED_NO_TERMVECTOR) 
-        return Collections.EMPTY_SET;
+        return Collections.<String>emptySet();
       if (fieldOption == FieldOption.TERMVECTOR_WITH_OFFSET && stride == 1) 
-        return Collections.EMPTY_SET;
+        return Collections.<String>emptySet();
       if (fieldOption == FieldOption.TERMVECTOR_WITH_POSITION_OFFSET && stride == 1) 
-        return Collections.EMPTY_SET;
+        return Collections.<String>emptySet();
       
       return Collections.unmodifiableSet(fields.keySet());
     }

Modified: lucene/java/trunk/contrib/memory/src/java/org/apache/lucene/index/memory/PatternAnalyzer.java
URL: http://svn.apache.org/viewvc/lucene/java/trunk/contrib/memory/src/java/org/apache/lucene/index/memory/PatternAnalyzer.java?rev=830790&r1=830789&r2=830790&view=diff
==============================================================================
--- lucene/java/trunk/contrib/memory/src/java/org/apache/lucene/index/memory/PatternAnalyzer.java (original)
+++ lucene/java/trunk/contrib/memory/src/java/org/apache/lucene/index/memory/PatternAnalyzer.java Wed Oct 28 23:21:25 2009
@@ -21,13 +21,13 @@
 import java.io.Reader;
 import java.io.StringReader;
 import java.util.Arrays;
-import java.util.HashSet;
 import java.util.Locale;
 import java.util.Set;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 import org.apache.lucene.analysis.Analyzer;
+import org.apache.lucene.analysis.CharArraySet;
 import org.apache.lucene.analysis.StopAnalyzer;
 import org.apache.lucene.analysis.StopFilter;
 import org.apache.lucene.analysis.TokenStream;
@@ -72,11 +72,8 @@
   /** <code>"\\s+"</code>; Divides text at whitespaces (Character.isWhitespace(c)) */
   public static final Pattern WHITESPACE_PATTERN = Pattern.compile("\\s+");
   
-  private static final Set EXTENDED_ENGLISH_STOP_WORDS;
-  static {
-    EXTENDED_ENGLISH_STOP_WORDS = new HashSet();
-  
-    EXTENDED_ENGLISH_STOP_WORDS.addAll(Arrays.asList(new String[] {
+  private static final CharArraySet EXTENDED_ENGLISH_STOP_WORDS =
+    CharArraySet.unmodifiableSet(new CharArraySet(Arrays.asList(
       "a", "about", "above", "across", "adj", "after", "afterwards",
       "again", "against", "albeit", "all", "almost", "alone", "along",
       "already", "also", "although", "always", "among", "amongst", "an",
@@ -117,8 +114,8 @@
       "whomever", "whomsoever", "whose", "whosoever", "why", "will",
       "with", "within", "without", "would", "xsubj", "xcal", "xauthor",
       "xother ", "xnote", "yet", "you", "your", "yours", "yourself",
-      "yourselves"}));
-  }
+      "yourselves"
+    ), true));
     
   /**
    * A lower-casing word analyzer with English stop words (can be shared
@@ -139,7 +136,7 @@
     
   private final Pattern pattern;
   private final boolean toLowerCase;
-  private final Set stopWords;
+  private final Set<?> stopWords;
 
   private final Version matchVersion;
   
@@ -162,7 +159,7 @@
    *            or <a href="http://www.unine.ch/info/clef/">other stop words
    *            lists </a>.
    */
-  public PatternAnalyzer(Version matchVersion, Pattern pattern, boolean toLowerCase, Set stopWords) {
+  public PatternAnalyzer(Version matchVersion, Pattern pattern, boolean toLowerCase, Set<?> stopWords) {
     if (pattern == null) 
       throw new IllegalArgumentException("pattern must not be null");
     
@@ -313,15 +310,7 @@
       if (input != null) input.close();
     }
   }
-    
-  /** somewhat oversized to minimize hash collisions */
-  private static Set makeStopSet(Set stopWords) {
-    Set stops = new HashSet(stopWords.size() * 2, 0.3f); 
-    stops.addAll(stopWords);
-    return stops;
-//    return Collections.unmodifiableSet(stops);
-  }
-
+  
   
   ///////////////////////////////////////////////////////////////////////////////
   // Nested classes:

Modified: lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/index/BalancedSegmentMergePolicy.java
URL: http://svn.apache.org/viewvc/lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/index/BalancedSegmentMergePolicy.java?rev=830790&r1=830789&r2=830790&view=diff
==============================================================================
--- lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/index/BalancedSegmentMergePolicy.java (original)
+++ lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/index/BalancedSegmentMergePolicy.java Wed Oct 28 23:21:25 2009
@@ -103,7 +103,7 @@
     }
   }
   
-  private boolean isOptimized(SegmentInfos infos, IndexWriter writer, int maxNumSegments, Set segmentsToOptimize) throws IOException {
+  private boolean isOptimized(SegmentInfos infos, IndexWriter writer, int maxNumSegments, Set<SegmentInfo> segmentsToOptimize) throws IOException {
     final int numSegments = infos.size();
     int numToOptimize = 0;
     SegmentInfo optimizeInfo = null;
@@ -128,7 +128,7 @@
   }
 
   @Override
-  public MergeSpecification findMergesForOptimize(SegmentInfos infos, int maxNumSegments, Set segmentsToOptimize) throws IOException {
+  public MergeSpecification findMergesForOptimize(SegmentInfos infos, int maxNumSegments, Set<SegmentInfo> segmentsToOptimize) throws IOException {
     
     assert maxNumSegments > 0;
 

Modified: lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/index/FieldNormModifier.java
URL: http://svn.apache.org/viewvc/lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/index/FieldNormModifier.java?rev=830790&r1=830789&r2=830790&view=diff
==============================================================================
--- lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/index/FieldNormModifier.java (original)
+++ lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/index/FieldNormModifier.java Wed Oct 28 23:21:25 2009
@@ -55,8 +55,7 @@
     Similarity s = null;
     if (!args[1].equals("-n")) {
       try {
-        Class simClass = Class.forName(args[1]);
-        s = (Similarity)simClass.newInstance();
+        s = Class.forName(args[1]).asSubclass(Similarity.class).newInstance();
       } catch (Exception e) {
         System.err.println("Couldn't instantiate similarity with empty constructor: " + args[1]);
         e.printStackTrace(System.err);
@@ -148,7 +147,7 @@
           if (sim == null)
             reader.setNorm(d, fieldName, fakeNorms[0]);
           else
-            reader.setNorm(d, fieldName, sim.encodeNorm(sim.lengthNorm(fieldName, termCounts[d])));
+            reader.setNorm(d, fieldName, Similarity.encodeNorm(sim.lengthNorm(fieldName, termCounts[d])));
         }
       }
       

Modified: lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/index/IndexSplitter.java
URL: http://svn.apache.org/viewvc/lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/index/IndexSplitter.java?rev=830790&r1=830789&r2=830790&view=diff
==============================================================================
--- lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/index/IndexSplitter.java (original)
+++ lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/index/IndexSplitter.java Wed Oct 28 23:21:25 2009
@@ -78,14 +78,14 @@
       for (int x = 2; x < args.length; x++) {
         segs.add(args[x]);
       }
-      is.remove((String[]) segs.toArray(new String[0]));
+      is.remove(segs.toArray(new String[0]));
     } else {
       File targetDir = new File(args[1]);
       List<String> segs = new ArrayList<String>();
       for (int x = 2; x < args.length; x++) {
         segs.add(args[x]);
       }
-      is.split(targetDir, (String[]) segs.toArray(new String[0]));
+      is.split(targetDir, segs.toArray(new String[0]));
     }
   }
 
@@ -137,9 +137,8 @@
       SegmentInfo info = getInfo(n);
       destInfos.add(info);
       // now copy files over
-      List files = info.files();
-      for (int x = 0; x < files.size(); x++) {
-        String srcName = (String) files.get(x);
+      List<String> files = info.files();
+      for (final String srcName : files) {
         File srcFile = new File(dir, srcName);
         File destFile = new File(destDir, srcName);
         copyFile(srcFile, destFile);

Modified: lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/index/MultiPassIndexSplitter.java
URL: http://svn.apache.org/viewvc/lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/index/MultiPassIndexSplitter.java?rev=830790&r1=830789&r2=830790&view=diff
==============================================================================
--- lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/index/MultiPassIndexSplitter.java (original)
+++ lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/index/MultiPassIndexSplitter.java Wed Oct 28 23:21:25 2009
@@ -158,7 +158,7 @@
     if (indexes.size() == 1) {
       input = indexes.get(0);
     } else {
-      input = new MultiReader((IndexReader[])indexes.toArray(new IndexReader[indexes.size()]));
+      input = new MultiReader(indexes.toArray(new IndexReader[indexes.size()]));
     }
     splitter.split(input, dirs, seq);
   }

Modified: lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/index/TermVectorAccessor.java
URL: http://svn.apache.org/viewvc/lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/index/TermVectorAccessor.java?rev=830790&r1=830789&r2=830790&view=diff
==============================================================================
--- lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/index/TermVectorAccessor.java (original)
+++ lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/index/TermVectorAccessor.java Wed Oct 28 23:21:25 2009
@@ -5,8 +5,6 @@
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Collection;
-import java.util.Iterator;
 /*
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
@@ -68,13 +66,13 @@
   }
 
   /** Instance reused to save garbage collector some time */
-  private List/*<String>*/ tokens;
+  private List<String> tokens;
 
   /** Instance reused to save garbage collector some time */
-  private List/*<int[]>*/ positions;
+  private List<int[]> positions;
 
   /** Instance reused to save garbage collector some time */
-  private List/*<Integer>*/ frequencies;
+  private List<Integer> frequencies;
 
 
   /**
@@ -90,9 +88,9 @@
   private void build(IndexReader indexReader, String field, TermVectorMapper mapper, int documentNumber) throws IOException {
 
     if (tokens == null) {
-      tokens = new ArrayList/*<String>*/(500);
-      positions = new ArrayList/*<int[]>*/(500);
-      frequencies = new ArrayList/*<Integer>*/(500);
+      tokens = new ArrayList<String>(500);
+      positions = new ArrayList<int[]>(500);
+      frequencies = new ArrayList<Integer>(500);
     } else {
       tokens.clear();
       frequencies.clear();
@@ -127,7 +125,7 @@
       mapper.setDocumentNumber(documentNumber);
       mapper.setExpectations(field, tokens.size(), false, !mapper.isIgnoringPositions());
       for (int i = 0; i < tokens.size(); i++) {
-        mapper.map((String) tokens.get(i), ((Integer) frequencies.get(i)).intValue(), (TermVectorOffsetInfo[]) null, (int[]) positions.get(i));
+        mapper.map(tokens.get(i), frequencies.get(i).intValue(), (TermVectorOffsetInfo[]) null, positions.get(i));
       }
     }
     termEnum.close();

Modified: lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/misc/HighFreqTerms.java
URL: http://svn.apache.org/viewvc/lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/misc/HighFreqTerms.java?rev=830790&r1=830789&r2=830790&view=diff
==============================================================================
--- lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/misc/HighFreqTerms.java (original)
+++ lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/misc/HighFreqTerms.java Wed Oct 28 23:21:25 2009
@@ -65,7 +65,7 @@
       }
     }
     while (tiq.size() != 0) {
-      TermInfo termInfo = (TermInfo) tiq.pop();
+      TermInfo termInfo = tiq.pop();
       System.out.println(termInfo.term + " " + termInfo.docFreq);
     }
 

Modified: lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/misc/LengthNormModifier.java
URL: http://svn.apache.org/viewvc/lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/misc/LengthNormModifier.java?rev=830790&r1=830789&r2=830790&view=diff
==============================================================================
--- lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/misc/LengthNormModifier.java (original)
+++ lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/misc/LengthNormModifier.java Wed Oct 28 23:21:25 2009
@@ -58,8 +58,7 @@
     
     Similarity s = null;
     try {
-      Class simClass = Class.forName(args[1]);
-      s = (Similarity)simClass.newInstance();
+      s = Class.forName(args[1]).asSubclass(Similarity.class).newInstance();
     } catch (Exception e) {
       System.err.println("Couldn't instantiate similarity with empty constructor: " + args[1]);
       e.printStackTrace(System.err);
@@ -142,7 +141,7 @@
       reader = IndexReader.open(dir, false); 
       for (int d = 0; d < termCounts.length; d++) {
         if (! reader.isDeleted(d)) {
-          byte norm = sim.encodeNorm(sim.lengthNorm(fieldName, termCounts[d]));
+          byte norm = Similarity.encodeNorm(sim.lengthNorm(fieldName, termCounts[d]));
           reader.setNorm(d, fieldName, norm);
         }
       }

Modified: lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/misc/SweetSpotSimilarity.java
URL: http://svn.apache.org/viewvc/lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/misc/SweetSpotSimilarity.java?rev=830790&r1=830789&r2=830790&view=diff
==============================================================================
--- lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/misc/SweetSpotSimilarity.java (original)
+++ lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/misc/SweetSpotSimilarity.java Wed Oct 28 23:21:25 2009
@@ -17,7 +17,6 @@
 
 package org.apache.lucene.misc;
 
-import org.apache.lucene.search.Similarity;
 import org.apache.lucene.search.DefaultSimilarity;
 import org.apache.lucene.index.FieldInvertState;
 
@@ -51,10 +50,10 @@
   private int ln_max = 1;
   private float ln_steep = 0.5f;
 
-  private Map ln_mins = new HashMap(7);
-  private Map ln_maxs = new HashMap(7);
-  private Map ln_steeps = new HashMap(7);
-  private Map ln_overlaps = new HashMap(7);
+  private Map<String,Number> ln_maxs = new HashMap<String,Number>(7);
+  private Map<String,Number> ln_mins = new HashMap<String,Number>(7);
+  private Map<String,Float> ln_steeps = new HashMap<String,Float>(7);
+  private Map<String,Boolean> ln_overlaps = new HashMap<String,Boolean>(7);
 
   private float tf_base = 0.0f;
   private float tf_min = 0.0f;
@@ -139,7 +138,7 @@
     final int numTokens;
     boolean overlaps = discountOverlaps;
     if (ln_overlaps.containsKey(fieldName)) {
-      overlaps = ((Boolean)ln_overlaps.get(fieldName)).booleanValue();
+      overlaps = ln_overlaps.get(fieldName).booleanValue();
     }
     if (overlaps)
       numTokens = state.getLength() - state.getNumOverlap();
@@ -173,13 +172,13 @@
     float s = ln_steep;
   
     if (ln_mins.containsKey(fieldName)) {
-      l = ((Number)ln_mins.get(fieldName)).intValue();
+      l = ln_mins.get(fieldName).intValue();
     }
     if (ln_maxs.containsKey(fieldName)) {
-      h = ((Number)ln_maxs.get(fieldName)).intValue();
+      h = ln_maxs.get(fieldName).intValue();
     }
     if (ln_steeps.containsKey(fieldName)) {
-      s = ((Number)ln_steeps.get(fieldName)).floatValue();
+      s = ln_steeps.get(fieldName).floatValue();
     }
   
     return (float)

Modified: lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/queryParser/analyzing/AnalyzingQueryParser.java
URL: http://svn.apache.org/viewvc/lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/queryParser/analyzing/AnalyzingQueryParser.java?rev=830790&r1=830789&r2=830790&view=diff
==============================================================================
--- lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/queryParser/analyzing/AnalyzingQueryParser.java (original)
+++ lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/queryParser/analyzing/AnalyzingQueryParser.java Wed Oct 28 23:21:25 2009
@@ -23,7 +23,6 @@
 import java.util.List;
 
 import org.apache.lucene.analysis.Analyzer;
-import org.apache.lucene.analysis.Token;
 import org.apache.lucene.analysis.TokenStream;
 import org.apache.lucene.analysis.tokenattributes.TermAttribute;
 import org.apache.lucene.queryParser.ParseException;
@@ -76,8 +75,8 @@
    * @throws ParseException
    */
   protected Query getWildcardQuery(String field, String termStr) throws ParseException {
-    List tlist = new ArrayList();
-    List wlist = new ArrayList();
+    List<String> tlist = new ArrayList<String>();
+    List<String> wlist = new ArrayList<String>();
     /* somewhat a hack: find/store wildcard chars
      * in order to put them back after analyzing */
     boolean isWithinToken = (!termStr.startsWith("?") && !termStr.startsWith("*"));
@@ -145,8 +144,8 @@
         /* if wlist contains one wildcard, it must be at the end, because:
          * 1) wildcards are not allowed in 1st position of a term by QueryParser
          * 2) if wildcard was *not* in end, there would be *two* or more tokens */
-        return super.getWildcardQuery(field, (String) tlist.get(0)
-            + (((String) wlist.get(0)).toString()));
+        return super.getWildcardQuery(field, tlist.get(0)
+            + wlist.get(0).toString());
       } else {
         /* we should never get here! if so, this method was called
          * with a termStr containing no wildcard ... */
@@ -157,9 +156,9 @@
        * with wildcards put back in postion */
       StringBuilder sb = new StringBuilder();
       for (int i = 0; i < tlist.size(); i++) {
-        sb.append((String) tlist.get(i));
+        sb.append( tlist.get(i));
         if (wlist != null && wlist.size() > i) {
-          sb.append((String) wlist.get(i));
+          sb.append(wlist.get(i));
         }
       }
       return super.getWildcardQuery(field, sb.toString());
@@ -188,7 +187,7 @@
   protected Query getPrefixQuery(String field, String termStr) throws ParseException {
     // get Analyzer from superclass and tokenize the term
     TokenStream source = getAnalyzer().tokenStream(field, new StringReader(termStr));
-    List tlist = new ArrayList();
+    List<String> tlist = new ArrayList<String>();
     TermAttribute termAtt = source.addAttribute(TermAttribute.class);
     
     while (true) {
@@ -207,7 +206,7 @@
     }
 
     if (tlist.size() == 1) {
-      return super.getPrefixQuery(field, (String) tlist.get(0));
+      return super.getPrefixQuery(field, tlist.get(0));
     } else {
       /* this means that the analyzer used either added or consumed
        * (common for a stemmer) tokens, and we can't build a PrefixQuery */

Modified: lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/queryParser/complexPhrase/ComplexPhraseQueryParser.java
URL: http://svn.apache.org/viewvc/lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/queryParser/complexPhrase/ComplexPhraseQueryParser.java?rev=830790&r1=830789&r2=830790&view=diff
==============================================================================
--- lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/queryParser/complexPhrase/ComplexPhraseQueryParser.java (original)
+++ lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/queryParser/complexPhrase/ComplexPhraseQueryParser.java Wed Oct 28 23:21:25 2009
@@ -62,7 +62,7 @@
  * 
  */
 public class ComplexPhraseQueryParser extends QueryParser {
-  private ArrayList/*<ComplexPhraseQuery>*/complexPhrases = null;
+  private ArrayList<ComplexPhraseQuery> complexPhrases = null;
 
   private boolean isPass2ResolvingPhrases;
 
@@ -102,7 +102,7 @@
 
     // First pass - parse the top-level query recording any PhraseQuerys
     // which will need to be resolved
-    complexPhrases = new ArrayList/*<ComplexPhraseQuery>*/();
+    complexPhrases = new ArrayList<ComplexPhraseQuery>();
     Query q = super.parse(query);
 
     // Perform second pass, using this QueryParser to parse any nested
@@ -110,8 +110,8 @@
     // set of syntax restrictions (i.e. all fields must be same)
     isPass2ResolvingPhrases = true;
     try {
-      for (Iterator iterator = complexPhrases.iterator(); iterator.hasNext();) {
-        currentPhraseQuery = (ComplexPhraseQuery) iterator.next();
+      for (Iterator<ComplexPhraseQuery> iterator = complexPhrases.iterator(); iterator.hasNext();) {
+        currentPhraseQuery = iterator.next();
         // in each phrase, now parse the contents between quotes as a
         // separate parse operation
         currentPhraseQuery.parsePhraseElements(this);
@@ -247,10 +247,10 @@
         }
 
         if (qc instanceof BooleanQuery) {
-          ArrayList sc = new ArrayList();
+          ArrayList<SpanQuery> sc = new ArrayList<SpanQuery>();
           addComplexPhraseClause(sc, (BooleanQuery) qc);
           if (sc.size() > 0) {
-            allSpanClauses[i] = (SpanQuery) sc.get(0);
+            allSpanClauses[i] = sc.get(0);
           } else {
             // Insert fake term e.g. phrase query was for "Fred Smithe*" and
             // there were no "Smithe*" terms - need to
@@ -278,14 +278,14 @@
       // Complex case - we have mixed positives and negatives in the
       // sequence.
       // Need to return a SpanNotQuery
-      ArrayList positiveClauses = new ArrayList();
+      ArrayList<SpanQuery> positiveClauses = new ArrayList<SpanQuery>();
       for (int j = 0; j < allSpanClauses.length; j++) {
         if (!bclauses[j].getOccur().equals(BooleanClause.Occur.MUST_NOT)) {
           positiveClauses.add(allSpanClauses[j]);
         }
       }
 
-      SpanQuery[] includeClauses = (SpanQuery[]) positiveClauses
+      SpanQuery[] includeClauses = positiveClauses
           .toArray(new SpanQuery[positiveClauses.size()]);
 
       SpanQuery include = null;
@@ -304,9 +304,9 @@
       return snot;
     }
 
-    private void addComplexPhraseClause(List spanClauses, BooleanQuery qc) {
-      ArrayList ors = new ArrayList();
-      ArrayList nots = new ArrayList();
+    private void addComplexPhraseClause(List<SpanQuery> spanClauses, BooleanQuery qc) {
+      ArrayList<SpanQuery> ors = new ArrayList<SpanQuery>();
+      ArrayList<SpanQuery> nots = new ArrayList<SpanQuery>();
       BooleanClause[] bclauses = qc.getClauses();
 
       // For all clauses e.g. one* two~
@@ -314,7 +314,7 @@
         Query childQuery = bclauses[i].getQuery();
 
         // select the list to which we will add these options
-        ArrayList chosenList = ors;
+        ArrayList<SpanQuery> chosenList = ors;
         if (bclauses[i].getOccur() == BooleanClause.Occur.MUST_NOT) {
           chosenList = nots;
         }
@@ -336,12 +336,12 @@
       if (ors.size() == 0) {
         return;
       }
-      SpanOrQuery soq = new SpanOrQuery((SpanQuery[]) ors
+      SpanOrQuery soq = new SpanOrQuery(ors
           .toArray(new SpanQuery[ors.size()]));
       if (nots.size() == 0) {
         spanClauses.add(soq);
       } else {
-        SpanOrQuery snqs = new SpanOrQuery((SpanQuery[]) nots
+        SpanOrQuery snqs = new SpanOrQuery(nots
             .toArray(new SpanQuery[nots.size()]));
         SpanNotQuery snq = new SpanNotQuery(soq, snqs);
         spanClauses.add(snq);

Modified: lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/queryParser/precedence/FastCharStream.java
URL: http://svn.apache.org/viewvc/lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/queryParser/precedence/FastCharStream.java?rev=830790&r1=830789&r2=830790&view=diff
==============================================================================
--- lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/queryParser/precedence/FastCharStream.java (original)
+++ lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/queryParser/precedence/FastCharStream.java Wed Oct 28 23:21:25 2009
@@ -18,7 +18,6 @@
  * limitations under the License.
  */
 
-import org.apache.lucene.queryParser.*;
 
 import java.io.*;
 

Modified: lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/queryParser/precedence/PrecedenceQueryParser.java
URL: http://svn.apache.org/viewvc/lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/queryParser/precedence/PrecedenceQueryParser.java?rev=830790&r1=830789&r2=830790&view=diff
==============================================================================
--- lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/queryParser/precedence/PrecedenceQueryParser.java (original)
+++ lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/queryParser/precedence/PrecedenceQueryParser.java Wed Oct 28 23:21:25 2009
@@ -8,7 +8,6 @@
 import java.util.Date;
 import java.util.List;
 import java.util.Locale;
-import java.util.Vector;
 
 import org.apache.lucene.analysis.Analyzer;
 import org.apache.lucene.analysis.TokenStream;
@@ -247,20 +246,13 @@
     return locale;
   }
 
-  /**
-   * @deprecated use {@link #addClause(List, int, int, Query)} instead.
-   */
-  protected void addClause(Vector clauses, int conj, int modifier, Query q) {
-    addClause((List) clauses, conj, modifier, q);
-  }
-
-  protected void addClause(List clauses, int conj, int modifier, Query q) {
+  protected void addClause(List<BooleanClause> clauses, int conj, int modifier, Query q) {
     boolean required, prohibited;
 
     // If this term is introduced by AND, make the preceding term required,
     // unless it's already prohibited
     if (clauses.size() > 0 && conj == CONJ_AND) {
-      BooleanClause c = (BooleanClause) clauses.get(clauses.size()-1);
+      BooleanClause c = clauses.get(clauses.size()-1);
       if (!c.isProhibited())
         c.setOccur(BooleanClause.Occur.MUST);
     }
@@ -270,7 +262,7 @@
       // unless it's prohibited (that means we leave -a OR b but +a OR b-->a OR b)
       // notice if the input is a OR b, first term is parsed as required; without
       // this modification a OR b would parsed as +a OR b
-      BooleanClause c = (BooleanClause) clauses.get(clauses.size()-1);
+      BooleanClause c = clauses.get(clauses.size()-1);
       if (!c.isProhibited())
         c.setOccur(BooleanClause.Occur.SHOULD);
     }
@@ -357,12 +349,12 @@
           for (int i = 0; i < list.size(); i++) {
             source.restoreState(list.get(i));
             if (posincrAtt.getPositionIncrement() == 1 && multiTerms.size() > 0) {
-              mpq.add((Term[])multiTerms.toArray(new Term[0]));
+              mpq.add(multiTerms.toArray(new Term[0]));
               multiTerms.clear();
             }
             multiTerms.add(new Term(field, termAtt.term()));
           }
-          mpq.add((Term[])multiTerms.toArray(new Term[0]));
+          mpq.add(multiTerms.toArray(new Term[0]));
           return mpq;
         }
       }
@@ -436,27 +428,8 @@
    *
    * @return Resulting {@link Query} object.
    * @exception ParseException throw in overridden method to disallow
-   * @deprecated use {@link #getBooleanQuery(List)} instead
    */
-  protected Query getBooleanQuery(Vector clauses) throws ParseException
-  {
-    return getBooleanQuery((List) clauses, false);
-  }
-
-  /**
-   * Factory method for generating query, given a set of clauses.
-   * By default creates a boolean query composed of clauses passed in.
-   *
-   * Can be overridden by extending classes, to modify query being
-   * returned.
-   *
-   * @param clauses List that contains {@link BooleanClause} instances
-   *    to join.
-   *
-   * @return Resulting {@link Query} object.
-   * @exception ParseException throw in overridden method to disallow
-   */
-  protected Query getBooleanQuery(List clauses) throws ParseException
+  protected Query getBooleanQuery(List<BooleanClause> clauses) throws ParseException
   {
     return getBooleanQuery(clauses, false);
   }
@@ -474,36 +447,15 @@
    *
    * @return Resulting {@link Query} object.
    * @exception ParseException throw in overridden method to disallow
-   * @deprecated use {@link #getBooleanQuery(List, boolean)} instead
-   */
-  protected Query getBooleanQuery(Vector clauses, boolean disableCoord)
-    throws ParseException
-  {
-    return getBooleanQuery((List) clauses, disableCoord);
-  }
-
-  /**
-   * Factory method for generating query, given a set of clauses.
-   * By default creates a boolean query composed of clauses passed in.
-   *
-   * Can be overridden by extending classes, to modify query being
-   * returned.
-   *
-   * @param clauses List that contains {@link BooleanClause} instances
-   *    to join.
-   * @param disableCoord true if coord scoring should be disabled.
-   *
-   * @return Resulting {@link Query} object.
-   * @exception ParseException throw in overridden method to disallow
    */
-  protected Query getBooleanQuery(List clauses, boolean disableCoord)
+  protected Query getBooleanQuery(List<BooleanClause> clauses, boolean disableCoord)
       throws ParseException {
     if (clauses == null || clauses.size() == 0)
       return null;
 
     BooleanQuery query = new BooleanQuery(disableCoord);
     for (int i = 0; i < clauses.size(); i++) {
-      query.add((BooleanClause)clauses.get(i));
+      query.add(clauses.get(i));
     }
     return query;
   }
@@ -705,7 +657,7 @@
   }
 
   final public Query Query(String field) throws ParseException {
-  List clauses = new ArrayList();
+  List<BooleanClause> clauses = new ArrayList<BooleanClause>();
   Query q, firstQuery=null;
   boolean orPresent = false;
   int modifier;
@@ -757,7 +709,7 @@
   }
 
   final public Query andExpression(String field) throws ParseException {
-  List clauses = new ArrayList();
+  List<BooleanClause> clauses = new ArrayList<BooleanClause>();
   Query q, firstQuery=null;
   int modifier;
     q = Clause(field);

Modified: lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/queryParser/precedence/PrecedenceQueryParser.jj
URL: http://svn.apache.org/viewvc/lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/queryParser/precedence/PrecedenceQueryParser.jj?rev=830790&r1=830789&r2=830790&view=diff
==============================================================================
--- lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/queryParser/precedence/PrecedenceQueryParser.jj (original)
+++ lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/queryParser/precedence/PrecedenceQueryParser.jj Wed Oct 28 23:21:25 2009
@@ -32,7 +32,6 @@
 import java.util.Date;
 import java.util.List;
 import java.util.Locale;
-import java.util.Vector;
 
 import org.apache.lucene.analysis.Analyzer;
 import org.apache.lucene.analysis.TokenStream;
@@ -271,20 +270,13 @@
     return locale;
   }
 
-  /**
-   * @deprecated use {@link #addClause(List, int, int, Query)} instead.
-   */
-  protected void addClause(Vector clauses, int conj, int modifier, Query q) {
-    addClause((List) clauses, conj, modifier, q);
-  }
-
-  protected void addClause(List clauses, int conj, int modifier, Query q) {
+  protected void addClause(List<BooleanClause> clauses, int conj, int modifier, Query q) {
     boolean required, prohibited;
 
     // If this term is introduced by AND, make the preceding term required,
     // unless it's already prohibited
     if (clauses.size() > 0 && conj == CONJ_AND) {
-      BooleanClause c = (BooleanClause) clauses.get(clauses.size()-1);
+      BooleanClause c = clauses.get(clauses.size()-1);
       if (!c.isProhibited())
         c.setOccur(BooleanClause.Occur.MUST);
     }
@@ -294,7 +286,7 @@
       // unless it's prohibited (that means we leave -a OR b but +a OR b-->a OR b)
       // notice if the input is a OR b, first term is parsed as required; without
       // this modification a OR b would parsed as +a OR b
-      BooleanClause c = (BooleanClause) clauses.get(clauses.size()-1);
+      BooleanClause c = clauses.get(clauses.size()-1);
       if (!c.isProhibited())
         c.setOccur(BooleanClause.Occur.SHOULD);
     }
@@ -381,12 +373,12 @@
           for (int i = 0; i < list.size(); i++) {
             source.restoreState(list.get(i));
             if (posincrAtt.getPositionIncrement() == 1 && multiTerms.size() > 0) {
-              mpq.add((Term[])multiTerms.toArray(new Term[0]));
+              mpq.add(multiTerms.toArray(new Term[0]));
               multiTerms.clear();
             }
             multiTerms.add(new Term(field, termAtt.term()));
           }
-          mpq.add((Term[])multiTerms.toArray(new Term[0]));
+          mpq.add(multiTerms.toArray(new Term[0]));
           return mpq;
         }
       }
@@ -460,27 +452,8 @@
    *
    * @return Resulting {@link Query} object.
    * @exception ParseException throw in overridden method to disallow
-   * @deprecated use {@link #getBooleanQuery(List)} instead
    */
-  protected Query getBooleanQuery(Vector clauses) throws ParseException
-  {
-    return getBooleanQuery((List) clauses, false);
-  }
-
-  /**
-   * Factory method for generating query, given a set of clauses.
-   * By default creates a boolean query composed of clauses passed in.
-   *
-   * Can be overridden by extending classes, to modify query being
-   * returned.
-   *
-   * @param clauses List that contains {@link BooleanClause} instances
-   *    to join.
-   *
-   * @return Resulting {@link Query} object.
-   * @exception ParseException throw in overridden method to disallow
-   */
-  protected Query getBooleanQuery(List clauses) throws ParseException
+  protected Query getBooleanQuery(List<BooleanClause> clauses) throws ParseException
   {
     return getBooleanQuery(clauses, false);
   }
@@ -498,36 +471,15 @@
    *
    * @return Resulting {@link Query} object.
    * @exception ParseException throw in overridden method to disallow
-   * @deprecated use {@link #getBooleanQuery(List, boolean)} instead
-   */
-  protected Query getBooleanQuery(Vector clauses, boolean disableCoord)
-    throws ParseException
-  {
-    return getBooleanQuery((List) clauses, disableCoord);
-  }
-
-  /**
-   * Factory method for generating query, given a set of clauses.
-   * By default creates a boolean query composed of clauses passed in.
-   *
-   * Can be overridden by extending classes, to modify query being
-   * returned.
-   *
-   * @param clauses List that contains {@link BooleanClause} instances
-   *    to join.
-   * @param disableCoord true if coord scoring should be disabled.
-   *
-   * @return Resulting {@link Query} object.
-   * @exception ParseException throw in overridden method to disallow
    */
-  protected Query getBooleanQuery(List clauses, boolean disableCoord)
+  protected Query getBooleanQuery(List<BooleanClause> clauses, boolean disableCoord)
       throws ParseException {
     if (clauses == null || clauses.size() == 0)
       return null;
 
     BooleanQuery query = new BooleanQuery(disableCoord);
     for (int i = 0; i < clauses.size(); i++) {
-      query.add((BooleanClause)clauses.get(i));
+      query.add(clauses.get(i));
     }
     return query;
   }
@@ -763,7 +715,7 @@
 
 Query Query(String field) :
 {
-  List clauses = new ArrayList();
+  List<BooleanClause> clauses = new ArrayList<BooleanClause>();
   Query q, firstQuery=null;
   boolean orPresent = false;
   int modifier;
@@ -790,7 +742,7 @@
 
 Query andExpression(String field) :
 {
-  List clauses = new ArrayList();
+  List<BooleanClause> clauses = new ArrayList<BooleanClause>();
   Query q, firstQuery=null;
   int modifier;
 }

Modified: lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/queryParser/precedence/PrecedenceQueryParserTokenManager.java
URL: http://svn.apache.org/viewvc/lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/queryParser/precedence/PrecedenceQueryParserTokenManager.java?rev=830790&r1=830789&r2=830790&view=diff
==============================================================================
--- lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/queryParser/precedence/PrecedenceQueryParserTokenManager.java (original)
+++ lucene/java/trunk/contrib/misc/src/java/org/apache/lucene/queryParser/precedence/PrecedenceQueryParserTokenManager.java Wed Oct 28 23:21:25 2009
@@ -7,7 +7,6 @@
 import java.util.Date;
 import java.util.List;
 import java.util.Locale;
-import java.util.Vector;
 import org.apache.lucene.analysis.Analyzer;
 import org.apache.lucene.analysis.TokenStream;
 import org.apache.lucene.analysis.tokenattributes.*;

Modified: lucene/java/trunk/contrib/wordnet/src/java/org/apache/lucene/wordnet/AnalyzerUtil.java
URL: http://svn.apache.org/viewvc/lucene/java/trunk/contrib/wordnet/src/java/org/apache/lucene/wordnet/AnalyzerUtil.java?rev=830790&r1=830789&r2=830790&view=diff
==============================================================================
--- lucene/java/trunk/contrib/wordnet/src/java/org/apache/lucene/wordnet/AnalyzerUtil.java (original)
+++ lucene/java/trunk/contrib/wordnet/src/java/org/apache/lucene/wordnet/AnalyzerUtil.java Wed Oct 28 23:21:25 2009
@@ -238,12 +238,12 @@
 
     return new Analyzer() {
 
-      private final HashMap cache = new HashMap();
+      private final HashMap<String,ArrayList<AttributeSource.State>> cache = new HashMap<String,ArrayList<AttributeSource.State>>();
 
       public TokenStream tokenStream(String fieldName, Reader reader) {
-        final ArrayList tokens = (ArrayList) cache.get(fieldName);
+        final ArrayList<AttributeSource.State> tokens = cache.get(fieldName);
         if (tokens == null) { // not yet cached
-          final ArrayList tokens2 = new ArrayList();
+          final ArrayList<AttributeSource.State> tokens2 = new ArrayList<AttributeSource.State>();
           TokenStream tokenStream = new TokenFilter(child.tokenStream(fieldName, reader)) {
 
             public boolean incrementToken() throws IOException {
@@ -258,11 +258,11 @@
         } else { // already cached
           return new TokenStream() {
 
-            private Iterator iter = tokens.iterator();
+            private Iterator<AttributeSource.State> iter = tokens.iterator();
 
             public boolean incrementToken() {
               if (!iter.hasNext()) return false;
-              restoreState((AttributeSource.State) iter.next());
+              restoreState(iter.next());
               return true;
             }
           };
@@ -305,12 +305,12 @@
     if (limit <= 0) limit = Integer.MAX_VALUE;
     
     // compute frequencies of distinct terms
-    HashMap map = new HashMap();
+    HashMap<String,MutableInteger> map = new HashMap<String,MutableInteger>();
     TokenStream stream = analyzer.tokenStream("", new StringReader(text));
     TermAttribute termAtt = stream.addAttribute(TermAttribute.class);
     try {
       while (stream.incrementToken()) {
-        MutableInteger freq = (MutableInteger) map.get(termAtt.term());
+        MutableInteger freq = map.get(termAtt.term());
         if (freq == null) {
           freq = new MutableInteger(1);
           map.put(termAtt.term(), freq);
@@ -329,17 +329,15 @@
     }
     
     // sort by frequency, text
-    Map.Entry[] entries = new Map.Entry[map.size()];
+    Map.Entry<String,MutableInteger>[] entries = new Map.Entry[map.size()];
     map.entrySet().toArray(entries);
-    Arrays.sort(entries, new Comparator() {
-      public int compare(Object o1, Object o2) {
-        Map.Entry e1 = (Map.Entry) o1;
-        Map.Entry e2 = (Map.Entry) o2;
-        int f1 = ((MutableInteger) e1.getValue()).intValue();
-        int f2 = ((MutableInteger) e2.getValue()).intValue();
+    Arrays.sort(entries, new Comparator<Map.Entry<String,MutableInteger>>() {
+      public int compare(Map.Entry<String,MutableInteger> e1, Map.Entry<String,MutableInteger> e2) {
+        int f1 = e1.getValue().intValue();
+        int f2 = e2.getValue().intValue();
         if (f2 - f1 != 0) return f2 - f1;
-        String s1 = (String) e1.getKey();
-        String s2 = (String) e2.getKey();
+        String s1 = e1.getKey();
+        String s2 = e2.getKey();
         return s1.compareTo(s2);
       }
     });

Modified: lucene/java/trunk/contrib/wordnet/src/java/org/apache/lucene/wordnet/SynonymMap.java
URL: http://svn.apache.org/viewvc/lucene/java/trunk/contrib/wordnet/src/java/org/apache/lucene/wordnet/SynonymMap.java?rev=830790&r1=830789&r2=830790&view=diff
==============================================================================
--- lucene/java/trunk/contrib/wordnet/src/java/org/apache/lucene/wordnet/SynonymMap.java (original)
+++ lucene/java/trunk/contrib/wordnet/src/java/org/apache/lucene/wordnet/SynonymMap.java Wed Oct 28 23:21:25 2009
@@ -76,7 +76,7 @@
 public class SynonymMap {
 
   /** the index data; Map<String word, String[] synonyms> */
-  private final HashMap table;
+  private final HashMap<String,String[]> table;
   
   private static final String[] EMPTY = new String[0];
   
@@ -93,7 +93,7 @@
    *             if an error occured while reading the stream.
    */
   public SynonymMap(InputStream input) throws IOException {
-    this.table = input == null ? new HashMap(0) : read(toByteArray(input));
+    this.table = input == null ? new HashMap<String,String[]>(0) : read(toByteArray(input));
   }
   
   /**
@@ -123,7 +123,7 @@
    */
   public String toString() {
     StringBuilder buf = new StringBuilder();
-    Iterator iter = new TreeMap(table).keySet().iterator();
+    Iterator<String> iter = new TreeMap<String,String[]>(table).keySet().iterator();
     int count = 0;
     int f0 = 0;
     int f1 = 0;
@@ -131,7 +131,7 @@
     int f3 = 0;
     
     while (iter.hasNext()) {
-      String word = (String) iter.next();
+      String word = iter.next();
       buf.append(word + ":");
       String[] synonyms = getSynonyms(word);
       buf.append(Arrays.asList(synonyms));
@@ -168,12 +168,12 @@
     return true;
   }
 
-  private HashMap read(byte[] data) {
+  private HashMap<String,String[]> read(byte[] data) {
     int WORDS  = (int) (76401 / 0.7); // presizing
     int GROUPS = (int) (88022 / 0.7); // presizing
-    HashMap word2Groups = new HashMap(WORDS);  // Map<String word, int[] groups>
-    HashMap group2Words = new HashMap(GROUPS); // Map<int group, String[] words>
-    HashMap internedWords = new HashMap(WORDS);// Map<String word, String word>
+    HashMap<String,ArrayList<Integer>> word2Groups = new HashMap<String,ArrayList<Integer>>(WORDS);  // Map<String word, int[] groups>
+    HashMap<Integer,ArrayList<String>> group2Words = new HashMap<Integer,ArrayList<String>>(GROUPS); // Map<int group, String[] words>
+    HashMap<String,String> internedWords = new HashMap<String,String>(WORDS);// Map<String word, String word>
 
     Charset charset = Charset.forName("UTF-8");
     int lastNum = -1;
@@ -226,7 +226,7 @@
       /* Part C: Add (group,word) to tables */
       
       // ensure compact string representation, minimizing memory overhead
-      String w = (String) internedWords.get(word);
+      String w = internedWords.get(word);
       if (w == null) {
         word = new String(word); // ensure compact string
         internedWords.put(word, word);
@@ -242,17 +242,17 @@
       }
       
       // add word --> group
-      ArrayList groups = (ArrayList) word2Groups.get(word);
+      ArrayList<Integer> groups =  word2Groups.get(word);
       if (groups == null) {
-        groups = new ArrayList(1);
+        groups = new ArrayList<Integer>(1);
         word2Groups.put(word, groups);
       }
       groups.add(group);
 
       // add group --> word
-      ArrayList words = (ArrayList) group2Words.get(group);
+      ArrayList<String> words = group2Words.get(group);
       if (words == null) {
-        words = new ArrayList(1);
+        words = new ArrayList<String>(1);
         group2Words.put(group, words);
       } 
       words.add(word);
@@ -265,25 +265,26 @@
     /* Part E: minimize memory consumption by a factor 3 (or so) */
 //    if (true) return word2Syns;
     word2Groups = null; // help gc
-    group2Words = null; // help gc    
+    //TODO: word2Groups.clear(); would be more appropriate  ? 
+    group2Words = null; // help gc
+    //TODO: group2Words.clear(); would be more appropriate  ? 
+    
     return optimize(word2Syns, internedWords);
   }
   
-  private HashMap createIndex(Map word2Groups, Map group2Words) {
-    HashMap word2Syns = new HashMap();
-    Iterator iter = word2Groups.entrySet().iterator();
-    
-    while (iter.hasNext()) { // for each word
-      Map.Entry entry = (Map.Entry) iter.next();
-      ArrayList group = (ArrayList) entry.getValue();     
-      String word = (String) entry.getKey();
+  private HashMap<String,String[]> createIndex(Map<String,ArrayList<Integer>> word2Groups, Map<Integer,ArrayList<String>> group2Words) {
+    HashMap<String,String[]> word2Syns = new HashMap<String,String[]>();
+    
+    for (final Map.Entry<String,ArrayList<Integer>> entry : word2Groups.entrySet()) { // for each word
+      ArrayList<Integer> group = entry.getValue();     
+      String word = entry.getKey();
       
 //      HashSet synonyms = new HashSet();
-      TreeSet synonyms = new TreeSet();
+      TreeSet<String> synonyms = new TreeSet<String>();
       for (int i=group.size(); --i >= 0; ) { // for each groupID of word
-        ArrayList words = (ArrayList) group2Words.get(group.get(i));
+        ArrayList<String> words = group2Words.get(group.get(i));
         for (int j=words.size(); --j >= 0; ) { // add all words       
-          Object synonym = words.get(j); // note that w and word are interned
+          String synonym = words.get(j); // note that w and word are interned
           if (synonym != word) { // a word is implicitly it's own synonym
             synonyms.add(synonym);
           }
@@ -294,7 +295,7 @@
       if (size > 0) {
         String[] syns = new String[size];
         if (size == 1)  
-          syns[0] = (String) synonyms.first();
+          syns[0] = synonyms.first();
         else
           synonyms.toArray(syns);
 //        if (syns.length > 1) Arrays.sort(syns);
@@ -306,7 +307,7 @@
     return word2Syns;
   }
 
-  private HashMap optimize(HashMap word2Syns, HashMap internedWords) {
+  private HashMap<String,String[]> optimize(HashMap word2Syns, HashMap<String,String> internedWords) {
     if (DEBUG) {
       System.err.println("before gc");
       for (int i=0; i < 10; i++) System.gc();
@@ -318,11 +319,11 @@
     int size = word2Syns.size();
     String[][] allSynonyms = new String[size][];
     String[] words = new String[size];
-    Iterator iter = word2Syns.entrySet().iterator();
+    Iterator<Map.Entry<String,String[]>> iter = word2Syns.entrySet().iterator();
     for (int j=0; j < size; j++) {
-      Map.Entry entry = (Map.Entry) iter.next();
-      allSynonyms[j] = (String[]) entry.getValue(); 
-      words[j] = (String) entry.getKey();
+      Map.Entry<String,String[]> entry = iter.next();
+      allSynonyms[j] = entry.getValue(); 
+      words[j] = entry.getKey();
       len += words[j].length();
     }
     
@@ -343,7 +344,7 @@
     for (int j=0; j < size; j++) {
       String[] syns = allSynonyms[j];
       for (int k=syns.length; --k >= 0; ) {
-        syns[k] = (String) internedWords.get(syns[k]);
+        syns[k] = internedWords.get(syns[k]);
       }
       Object replacement = syns;
       if (syns.length == 1) replacement = syns[0]; // minimize memory consumption some more



Mime
View raw message