Index: lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/SpanOrBuilder.java
===================================================================
--- lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/SpanOrBuilder.java	(revision 834414)
+++ lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/SpanOrBuilder.java	Thu Jul 14 17:15:25 NZST 2011
@@ -1,13 +1,14 @@
 package org.apache.lucene.xmlparser.builders;
 
-import java.util.ArrayList;
-
 import org.apache.lucene.search.spans.SpanOrQuery;
 import org.apache.lucene.search.spans.SpanQuery;
 import org.apache.lucene.xmlparser.DOMUtils;
 import org.apache.lucene.xmlparser.ParserException;
 import org.w3c.dom.Element;
 import org.w3c.dom.Node;
+
+import java.util.ArrayList;
+import java.util.List;
 /**
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -26,34 +27,29 @@
  */
 
 /**
- * 
+ *
  */
-public class SpanOrBuilder extends SpanBuilderBase
-{
+public class SpanOrBuilder extends SpanBuilderBase {
-    
+
-    SpanQueryBuilder factory;
+  private final SpanQueryBuilder factory;
-    
+
-    public SpanOrBuilder(SpanQueryBuilder factory)
-    {
+  public SpanOrBuilder(SpanQueryBuilder factory) {
-        super();
-        this.factory = factory;
-    }
-    
+    super();
+    this.factory = factory;
+  }
+
-	public SpanQuery getSpanQuery(Element e) throws ParserException
-	{
-	    ArrayList<SpanQuery> clausesList=new ArrayList<SpanQuery>();
-		for (Node kid = e.getFirstChild(); kid != null; kid = kid.getNextSibling())
-		{
-			if (kid.getNodeType() == Node.ELEMENT_NODE) 
-			{
+  public SpanQuery getSpanQuery(Element e) throws ParserException {
+    List<SpanQuery> clausesList = new ArrayList<SpanQuery>();
+    for (Node kid = e.getFirstChild(); kid != null; kid = kid.getNextSibling()) {
+      if (kid.getNodeType() == Node.ELEMENT_NODE) {
-				SpanQuery clause=factory.getSpanQuery((Element) kid);
+        SpanQuery clause = factory.getSpanQuery((Element) kid);
-				clausesList.add(clause);				
-			}
-		}	    
+        clausesList.add(clause);
+      }
+    }
-		SpanQuery[] clauses= clausesList.toArray(new SpanQuery[clausesList.size()]);
+    SpanQuery[] clauses = clausesList.toArray(new SpanQuery[clausesList.size()]);
-		SpanOrQuery soq = new SpanOrQuery(clauses);		
+    SpanOrQuery soq = new SpanOrQuery(clauses);
-		soq.setBoost(DOMUtils.getAttribute(e,"boost",1.0f));
+    soq.setBoost(DOMUtils.getAttribute(e, "boost", 1.0f));
-		return soq;
-	}
+    return soq;
+  }
 
 }
Index: lucene/contrib/xml-query-parser/src/test/org/apache/lucene/xmlparser/TestQueryTemplateManager.java
===================================================================
--- lucene/contrib/xml-query-parser/src/test/org/apache/lucene/xmlparser/TestQueryTemplateManager.java	(revision 1091132)
+++ lucene/contrib/xml-query-parser/src/test/org/apache/lucene/xmlparser/TestQueryTemplateManager.java	Thu Jul 14 17:19:09 NZST 2011
@@ -1,13 +1,5 @@
 package org.apache.lucene.xmlparser;
 
-import java.io.IOException;
-import java.util.Locale;
-import java.util.Properties;
-import java.util.StringTokenizer;
-
-import javax.xml.parsers.ParserConfigurationException;
-import javax.xml.transform.TransformerException;
-
 import org.apache.lucene.analysis.Analyzer;
 import org.apache.lucene.analysis.MockAnalyzer;
 import org.apache.lucene.document.Field;
@@ -17,10 +9,16 @@
 import org.apache.lucene.store.Directory;
 import org.apache.lucene.util.Constants;
 import org.apache.lucene.util.LuceneTestCase;
-
 import org.w3c.dom.Document;
 import org.xml.sax.SAXException;
 
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.transform.TransformerException;
+import java.io.IOException;
+import java.util.Locale;
+import java.util.Properties;
+import java.util.StringTokenizer;
+
 /**
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -37,138 +35,128 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 /**
  * This class illustrates how form input (such as from a web page or Swing gui) can be
  * turned into Lucene queries using a choice of XSL templates for different styles of queries.
  */
 public class TestQueryTemplateManager extends LuceneTestCase {
 
-	CoreParser builder;
-	Analyzer analyzer=new MockAnalyzer(random);
+  private CoreParser builder;
+  private final Analyzer analyzer = new MockAnalyzer(random);
-	private IndexSearcher searcher;
-	private Directory dir;
-	
-	//A collection of documents' field values for use in our tests
+  private IndexSearcher searcher;
+  private Directory dir;
+
+  //A collection of documents' field values for use in our tests
-	String docFieldValues []=
+  String docFieldValues[] =
-	{
-			"artist=Jeff Buckley \talbum=Grace \treleaseDate=1999 \tgenre=rock",
-			"artist=Fugazi \talbum=Repeater \treleaseDate=1990 \tgenre=alternative",
-			"artist=Fugazi \talbum=Red Medicine \treleaseDate=1995 \tgenre=alternative",
-			"artist=Peeping Tom \talbum=Peeping Tom \treleaseDate=2006 \tgenre=rock",
-			"artist=Red Snapper \talbum=Prince Blimey \treleaseDate=1996 \tgenre=electronic"
-	};
-	
-	//A collection of example queries, consisting of name/value pairs representing form content plus 
-	// a choice of query style template to use in the test, with expected number of hits
+      {
+          "artist=Jeff Buckley \talbum=Grace \treleaseDate=1999 \tgenre=rock",
+          "artist=Fugazi \talbum=Repeater \treleaseDate=1990 \tgenre=alternative",
+          "artist=Fugazi \talbum=Red Medicine \treleaseDate=1995 \tgenre=alternative",
+          "artist=Peeping Tom \talbum=Peeping Tom \treleaseDate=2006 \tgenre=rock",
+          "artist=Red Snapper \talbum=Prince Blimey \treleaseDate=1996 \tgenre=electronic"
+      };
+
+  //A collection of example queries, consisting of name/value pairs representing form content plus
+  // a choice of query style template to use in the test, with expected number of hits
-	String queryForms[]=
+  String queryForms[] =
-	{
-			"artist=Fugazi \texpectedMatches=2 \ttemplate=albumBooleanQuery",
-			"artist=Fugazi \treleaseDate=1990 \texpectedMatches=1 \ttemplate=albumBooleanQuery",
-			"artist=Buckley \tgenre=rock \texpectedMatches=1 \ttemplate=albumFilteredQuery",
-			"artist=Buckley \tgenre=electronic \texpectedMatches=0 \ttemplate=albumFilteredQuery",
-			"queryString=artist:buckly~ NOT genre:electronic \texpectedMatches=1 \ttemplate=albumLuceneClassicQuery"
-	};
-	
-	
+      {
+          "artist=Fugazi \texpectedMatches=2 \ttemplate=albumBooleanQuery",
+          "artist=Fugazi \treleaseDate=1990 \texpectedMatches=1 \ttemplate=albumBooleanQuery",
+          "artist=Buckley \tgenre=rock \texpectedMatches=1 \ttemplate=albumFilteredQuery",
+          "artist=Buckley \tgenre=electronic \texpectedMatches=0 \ttemplate=albumFilteredQuery",
+          "queryString=artist:buckly~ NOT genre:electronic \texpectedMatches=1 \ttemplate=albumLuceneClassicQuery"
+      };
+
+
-	public void testFormTransforms() throws SAXException, IOException, ParserConfigurationException, TransformerException, ParserException 
-	{
+  public void testFormTransforms() throws SAXException, IOException, ParserConfigurationException, TransformerException, ParserException {
-	  // Sun 1.5 suffers from http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6240963
-	  if (Constants.JAVA_VENDOR.startsWith("Sun") && Constants.JAVA_VERSION.startsWith("1.5")) {
-	    String defLang = Locale.getDefault().getLanguage();
-	    assumeFalse("Sun JRE 1.5 suffers from http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6240963 under Turkish locale", defLang.equals("tr") || defLang.equals("az"));
-	  }
-		//Cache all the query templates we will be referring to.
+    // Sun 1.5 suffers from http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6240963
+    if (Constants.JAVA_VENDOR.startsWith("Sun") && Constants.JAVA_VERSION.startsWith("1.5")) {
+      String defLang = Locale.getDefault().getLanguage();
+      assumeFalse("Sun JRE 1.5 suffers from http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6240963 under Turkish locale", defLang.equals("tr") || defLang.equals("az"));
+    }
+    //Cache all the query templates we will be referring to.
-		QueryTemplateManager qtm=new QueryTemplateManager();
+    QueryTemplateManager qtm = new QueryTemplateManager();
-		qtm.addQueryTemplate("albumBooleanQuery", getClass().getResourceAsStream("albumBooleanQuery.xsl"));
-		qtm.addQueryTemplate("albumFilteredQuery", getClass().getResourceAsStream("albumFilteredQuery.xsl"));
-		qtm.addQueryTemplate("albumLuceneClassicQuery", getClass().getResourceAsStream("albumLuceneClassicQuery.xsl"));
-		//Run all of our test queries
+    qtm.addQueryTemplate("albumBooleanQuery", getClass().getResourceAsStream("albumBooleanQuery.xsl"));
+    qtm.addQueryTemplate("albumFilteredQuery", getClass().getResourceAsStream("albumFilteredQuery.xsl"));
+    qtm.addQueryTemplate("albumLuceneClassicQuery", getClass().getResourceAsStream("albumLuceneClassicQuery.xsl"));
+    //Run all of our test queries
-		for (int i = 0; i < queryForms.length; i++)
-		{
-			Properties queryFormProperties=getPropsFromString(queryForms[i]);
+    for (String queryForm : queryForms) {
+      Properties queryFormProperties = getPropsFromString(queryForm);
-			
-			//Get the required query XSL template for this test
+
+      //Get the required query XSL template for this test
 //			Templates template=getTemplate(queryFormProperties.getProperty("template"));
-			
-			//Transform the queryFormProperties into a Lucene XML query
+
+      //Transform the queryFormProperties into a Lucene XML query
-			Document doc=qtm.getQueryAsDOM(queryFormProperties,queryFormProperties.getProperty("template"));
+      Document doc = qtm.getQueryAsDOM(queryFormProperties, queryFormProperties.getProperty("template"));
-			
-			//Parse the XML query using the XML parser
+
+      //Parse the XML query using the XML parser
-			Query q=builder.getQuery(doc.getDocumentElement());
+      Query q = builder.getQuery(doc.getDocumentElement());
-			
-			//Run the query
+
+      //Run the query
-			int h=searcher.search(q, null, 1000).totalHits;
+      int h = searcher.search(q, null, 1000).totalHits;
-			
-			//Check we have the expected number of results
+
+      //Check we have the expected number of results
-			int expectedHits=Integer.parseInt(queryFormProperties.getProperty("expectedMatches"));
+      int expectedHits = Integer.parseInt(queryFormProperties.getProperty("expectedMatches"));
-			assertEquals("Number of results should match for query "+queryForms[i],expectedHits,h);
+      assertEquals("Number of results should match for query " + queryForm, expectedHits, h);
-			
-		}
-	}
-	
-	//Helper method to construct Lucene query forms used in our test
+
+    }
+  }
+
+  //Helper method to construct Lucene query forms used in our test
-	Properties getPropsFromString(String nameValuePairs)
-	{
+  Properties getPropsFromString(String nameValuePairs) {
-		Properties result=new Properties();
+    Properties result = new Properties();
-		StringTokenizer st=new StringTokenizer(nameValuePairs,"\t=");
+    StringTokenizer st = new StringTokenizer(nameValuePairs, "\t=");
-		while(st.hasMoreTokens())
-		{
+    while (st.hasMoreTokens()) {
-			String name=st.nextToken().trim();
+      String name = st.nextToken().trim();
-			if(st.hasMoreTokens())
-			{
+      if (st.hasMoreTokens()) {
-				String value=st.nextToken().trim();
+        String value = st.nextToken().trim();
-				result.setProperty(name,value);
+        result.setProperty(name, value);
-			}
-		}
-		return result;
-	}
-	
-	//Helper method to construct Lucene documents used in our tests
+      }
+    }
+    return result;
+  }
+
+  //Helper method to construct Lucene documents used in our tests
-	org.apache.lucene.document.Document getDocumentFromString(String nameValuePairs)
-	{
+  org.apache.lucene.document.Document getDocumentFromString(String nameValuePairs) {
-		org.apache.lucene.document.Document result=new org.apache.lucene.document.Document();
+    org.apache.lucene.document.Document result = new org.apache.lucene.document.Document();
-		StringTokenizer st=new StringTokenizer(nameValuePairs,"\t=");
+    StringTokenizer st = new StringTokenizer(nameValuePairs, "\t=");
-		while(st.hasMoreTokens())
-		{
+    while (st.hasMoreTokens()) {
-			String name=st.nextToken().trim();
+      String name = st.nextToken().trim();
-			if(st.hasMoreTokens())
-			{
+      if (st.hasMoreTokens()) {
-				String value=st.nextToken().trim();
+        String value = st.nextToken().trim();
-				result.add(newField(name,value,Field.Store.YES,Field.Index.ANALYZED));
+        result.add(newField(name, value, Field.Store.YES, Field.Index.ANALYZED));
-			}
-		}
-		return result;
-	}
-	
-	/*
-	 * @see TestCase#setUp()
-	 */
-	@Override
-	public void setUp() throws Exception {
-		super.setUp();
-		
+      }
+    }
+    return result;
+  }
+
+  /*
+    * @see TestCase#setUp()
+    */
+  @Override
+  public void setUp() throws Exception {
+    super.setUp();
+
-		
-		//Create an index
+    //Create an index
-		dir=newDirectory();
+    dir = newDirectory();
-		IndexWriter w=new IndexWriter(dir, newIndexWriterConfig(TEST_VERSION_CURRENT, analyzer));
+    IndexWriter w = new IndexWriter(dir, newIndexWriterConfig(TEST_VERSION_CURRENT, analyzer));
-		for (int i = 0; i < docFieldValues.length; i++)
-		{
-			w.addDocument(getDocumentFromString(docFieldValues[i]));
+    for (String docFieldValue : docFieldValues) {
+      w.addDocument(getDocumentFromString(docFieldValue));
-		}
-		w.optimize();
-		w.close();
+    }
+    w.optimize();
+    w.close();
-		searcher=new IndexSearcher(dir, true);
+    searcher = new IndexSearcher(dir, true);
-		
-		//initialize the parser
+
+    //initialize the parser
-		builder=new CorePlusExtensionsParser("artist", analyzer);
+    builder = new CorePlusExtensionsParser("artist", analyzer);
-		
-	}
-	
+
+  }
+
-	
-	@Override
-	public void tearDown() throws Exception {
-		searcher.close();
-		dir.close();
+  @Override
+  public void tearDown() throws Exception {
+    searcher.close();
+    dir.close();
     super.tearDown();
-	}
+  }
 }
Index: lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/SpanBuilderBase.java
===================================================================
--- lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/SpanBuilderBase.java	(revision 811070)
+++ lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/SpanBuilderBase.java	Thu Jul 14 17:09:07 NZST 2011
@@ -21,13 +21,12 @@
  */
 
 /**
- * 
+ *
  */
-public abstract class SpanBuilderBase implements SpanQueryBuilder
-{
-	public Query getQuery(Element e) throws ParserException
-	{
+public abstract class SpanBuilderBase implements SpanQueryBuilder {
+  
+  public Query getQuery(Element e) throws ParserException {
-		return getSpanQuery(e);
-	}
+    return getSpanQuery(e);
+  }
 
 }
Index: lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/QueryBuilderFactory.java
===================================================================
--- lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/QueryBuilderFactory.java	(revision 834414)
+++ lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/QueryBuilderFactory.java	Thu Jul 14 16:58:10 NZST 2011
@@ -3,10 +3,10 @@
  */
 package org.apache.lucene.xmlparser;
 
-import java.util.HashMap;
-
 import org.apache.lucene.search.Query;
 import org.w3c.dom.Element;
+
+import java.util.HashMap;
 /**
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -25,27 +25,26 @@
  */
 
 /**
- * 
+ *
  */
 public class QueryBuilderFactory implements QueryBuilder {
 
-	HashMap<String,QueryBuilder> builders=new HashMap<String,QueryBuilder>();
+  HashMap<String, QueryBuilder> builders = new HashMap<String, QueryBuilder>();
-	
-	public Query getQuery(Element n) throws ParserException {
+
+  public Query getQuery(Element n) throws ParserException {
-		QueryBuilder builder= builders.get(n.getNodeName());
+    QueryBuilder builder = builders.get(n.getNodeName());
-		if(builder==null)
-		{
+    if (builder == null) {
-			throw new ParserException("No QueryObjectBuilder defined for node "+n.getNodeName()); 
+      throw new ParserException("No QueryObjectBuilder defined for node " + n.getNodeName());
-		}
-		return builder.getQuery(n); 
-	}
+    }
+    return builder.getQuery(n);
+  }
-	public void addBuilder(String nodeName,QueryBuilder builder)
-	{
+
+  public void addBuilder(String nodeName, QueryBuilder builder) {
-		builders.put(nodeName,builder);
+    builders.put(nodeName, builder);
-	}
+  }
-	public QueryBuilder getQueryBuilder(String nodeName)
-	{
+
+  public QueryBuilder getQueryBuilder(String nodeName) {
-		return builders.get(nodeName);		
-	}
-	
+    return builders.get(nodeName);
+  }
+
 }
Index: lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/ConstantScoreQueryBuilder.java
===================================================================
--- lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/ConstantScoreQueryBuilder.java	(revision 811070)
+++ lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/ConstantScoreQueryBuilder.java	Thu Jul 14 17:02:16 NZST 2011
@@ -25,26 +25,22 @@
  */
 
 /**
- * 
+ *
  */
-public class ConstantScoreQueryBuilder implements QueryBuilder
-{
-	private FilterBuilderFactory filterFactory;
+public class ConstantScoreQueryBuilder implements QueryBuilder {
 
-	public ConstantScoreQueryBuilder(FilterBuilderFactory filterFactory)
-	{
+  private final FilterBuilderFactory filterFactory;
+
+  public ConstantScoreQueryBuilder(FilterBuilderFactory filterFactory) {
-		this.filterFactory=filterFactory;
+    this.filterFactory = filterFactory;
-	}
+  }
 
-	public Query getQuery(Element e) throws ParserException
-	{
+  public Query getQuery(Element e) throws ParserException {
- 		Element filterElem=DOMUtils.getFirstChildOrFail(e);
+    Element filterElem = DOMUtils.getFirstChildOrFail(e);
-  		Query q=new ConstantScoreQuery(filterFactory.getFilter(filterElem));
 
+    Query q = new ConstantScoreQuery(filterFactory.getFilter(filterElem));
-  		q.setBoost(DOMUtils.getAttribute(e,"boost",1.0f));
+    q.setBoost(DOMUtils.getAttribute(e, "boost", 1.0f));
-
-  		return q;
+    return q;
-		
-	}
+  }
 
 }
Index: lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/SpanTermBuilder.java
===================================================================
--- lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/SpanTermBuilder.java	(revision 811070)
+++ lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/SpanTermBuilder.java	Thu Jul 14 17:11:12 NZST 2011
@@ -24,20 +24,17 @@
  */
 
 /**
- * 
+ *
  */
-public class SpanTermBuilder extends SpanBuilderBase
-{
+public class SpanTermBuilder extends SpanBuilderBase {
 
-	public SpanQuery getSpanQuery(Element e) throws ParserException
-	{
+  public SpanQuery getSpanQuery(Element e) throws ParserException {
- 		String fieldName=DOMUtils.getAttributeWithInheritanceOrFail(e,"fieldName");
+    String fieldName = DOMUtils.getAttributeWithInheritanceOrFail(e, "fieldName");
- 		String value=DOMUtils.getNonBlankTextOrFail(e);
+    String value = DOMUtils.getNonBlankTextOrFail(e);
-  		SpanTermQuery stq = new SpanTermQuery(new Term(fieldName,value));
+    SpanTermQuery stq = new SpanTermQuery(new Term(fieldName, value));
-  		
+
-  		stq.setBoost(DOMUtils.getAttribute(e,"boost",1.0f));
+    stq.setBoost(DOMUtils.getAttribute(e, "boost", 1.0f));
-		return stq;		
+    return stq;
-		
-	}
+  }
 
 }
Index: lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/RangeFilterBuilder.java
===================================================================
--- lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/RangeFilterBuilder.java	(revision 1075210)
+++ lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/RangeFilterBuilder.java	Thu Jul 14 17:09:07 NZST 2011
@@ -28,20 +28,18 @@
 
 
 /**
- * 
+ *
  */
 public class RangeFilterBuilder implements FilterBuilder {
 
-
-	public Filter getFilter(Element e) throws ParserException {
+  public Filter getFilter(Element e) throws ParserException {
-		
-		String fieldName=DOMUtils.getAttributeWithInheritance(e,"fieldName");
+    String fieldName = DOMUtils.getAttributeWithInheritance(e, "fieldName");
-		
+
-		String lowerTerm=e.getAttribute("lowerTerm");
+    String lowerTerm = e.getAttribute("lowerTerm");
-		String upperTerm=e.getAttribute("upperTerm");
+    String upperTerm = e.getAttribute("upperTerm");
-		boolean includeLower=DOMUtils.getAttribute(e,"includeLower",true);
+    boolean includeLower = DOMUtils.getAttribute(e, "includeLower", true);
-		boolean includeUpper=DOMUtils.getAttribute(e,"includeUpper",true);
+    boolean includeUpper = DOMUtils.getAttribute(e, "includeUpper", true);
-		return TermRangeFilter.newStringRange(fieldName,lowerTerm,upperTerm,includeLower,includeUpper);
+    return TermRangeFilter.newStringRange(fieldName, lowerTerm, upperTerm, includeLower, includeUpper);
-	}
+  }
 
 }
Index: lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/FilterBuilder.java
===================================================================
--- lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/FilterBuilder.java	(revision 811070)
+++ lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/FilterBuilder.java	Thu Jul 14 16:58:10 NZST 2011
@@ -26,5 +26,6 @@
  * 
  */
 public interface FilterBuilder {
+
 	 public Filter getFilter(Element e) throws ParserException;
 }
Index: lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/SpanFirstBuilder.java
===================================================================
--- lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/SpanFirstBuilder.java	(revision 811070)
+++ lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/SpanFirstBuilder.java	Thu Jul 14 17:09:07 NZST 2011
@@ -23,28 +23,26 @@
  */
 
 /**
- * 
+ *
  */
-public class SpanFirstBuilder extends SpanBuilderBase
-{
-    SpanQueryBuilder factory;
+public class SpanFirstBuilder extends SpanBuilderBase {
-    
+
-    public SpanFirstBuilder(SpanQueryBuilder factory)
-    {
+  private final SpanQueryBuilder factory;
+
+  public SpanFirstBuilder(SpanQueryBuilder factory) {
-        super();
-        this.factory = factory;
-    }
+    super();
+    this.factory = factory;
+  }
 
-	public SpanQuery getSpanQuery(Element e) throws ParserException
-	{
+  public SpanQuery getSpanQuery(Element e) throws ParserException {
-	    int end=DOMUtils.getAttribute(e,"end",1);
+    int end = DOMUtils.getAttribute(e, "end", 1);
-	    Element child=DOMUtils.getFirstChildElement(e);
+    Element child = DOMUtils.getFirstChildElement(e);
-	    SpanQuery q=factory.getSpanQuery(child);
+    SpanQuery q = factory.getSpanQuery(child);
-	    
+
-		SpanFirstQuery sfq = new SpanFirstQuery(q,end);
+    SpanFirstQuery sfq = new SpanFirstQuery(q, end);
-		
+
-		sfq.setBoost(DOMUtils.getAttribute(e,"boost",1.0f));
+    sfq.setBoost(DOMUtils.getAttribute(e, "boost", 1.0f));
-		return sfq;
-	}
+    return sfq;
+  }
 
 }
Index: lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/LikeThisQueryBuilder.java
===================================================================
--- lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/LikeThisQueryBuilder.java	(revision 1146542)
+++ lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/LikeThisQueryBuilder.java	Thu Jul 14 17:08:04 NZST 2011
@@ -3,11 +3,6 @@
  */
 package org.apache.lucene.xmlparser.builders;
 
-import java.io.IOException;
-import java.io.StringReader;
-import java.util.HashSet;
-import java.util.Set;
-
 import org.apache.lucene.analysis.Analyzer;
 import org.apache.lucene.analysis.TokenStream;
 import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;
@@ -17,6 +12,11 @@
 import org.apache.lucene.xmlparser.ParserException;
 import org.apache.lucene.xmlparser.QueryBuilder;
 import org.w3c.dom.Element;
+
+import java.io.IOException;
+import java.io.StringReader;
+import java.util.HashSet;
+import java.util.Set;
 /**
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -35,83 +35,76 @@
  */
 
 /**
- * 
+ *
  */
 public class LikeThisQueryBuilder implements QueryBuilder {
 
-	private Analyzer analyzer;
-	String defaultFieldNames [];
-	int defaultMaxQueryTerms=20;
-	int defaultMinTermFrequency=1;
-	float defaultPercentTermsToMatch=30; //default is a 3rd of selected terms must match
+  private static final int DEFAULT_MAX_QUERY_TERMS = 20;
+  private static final int DEFAULT_MIN_TERM_FREQUENCY = 1;
+  private static final float DEFAULT_PERCENT_TERMS_TO_MATCH = 30; //default is a 3rd of selected terms must match
 
-	public LikeThisQueryBuilder(Analyzer analyzer,String [] defaultFieldNames)
-	{
+  private final Analyzer analyzer;
+  private final String defaultFieldNames[];
+
+  public LikeThisQueryBuilder(Analyzer analyzer, String[] defaultFieldNames) {
-		this.analyzer=analyzer;
+    this.analyzer = analyzer;
-		this.defaultFieldNames=defaultFieldNames;
+    this.defaultFieldNames = defaultFieldNames;
-	}
-	
-	/* (non-Javadoc)
-	 * @see org.apache.lucene.xmlparser.QueryObjectBuilder#process(org.w3c.dom.Element)
-	 */
-	public Query getQuery(Element e) throws ParserException {
+  }
+
+  /* (non-Javadoc)
+    * @see org.apache.lucene.xmlparser.QueryObjectBuilder#process(org.w3c.dom.Element)
+    */
+  public Query getQuery(Element e) throws ParserException {
-		String fieldsList=e.getAttribute("fieldNames"); //a comma-delimited list of fields
+    String fieldsList = e.getAttribute("fieldNames"); //a comma-delimited list of fields
-		String fields[]=defaultFieldNames;
+    String fields[] = defaultFieldNames;
-		if((fieldsList!=null)&&(fieldsList.trim().length()>0))
-		{
+    if ((fieldsList != null) && (fieldsList.trim().length() > 0)) {
-			fields=fieldsList.trim().split(",");
+      fields = fieldsList.trim().split(",");
-			//trim the fieldnames
-			for (int i = 0; i < fields.length; i++) {
+      //trim the fieldnames
+      for (int i = 0; i < fields.length; i++) {
-				fields[i]=fields[i].trim();
+        fields[i] = fields[i].trim();
-			}
-		}
-		
-		//Parse any "stopWords" attribute
-		//TODO MoreLikeThis needs to ideally have per-field stopWords lists - until then 
-		//I use all analyzers/fields to generate multi-field compatible stop list
+      }
+    }
+
+    //Parse any "stopWords" attribute
+    //TODO MoreLikeThis needs to ideally have per-field stopWords lists - until then
+    //I use all analyzers/fields to generate multi-field compatible stop list
-		String stopWords=e.getAttribute("stopWords");
+    String stopWords = e.getAttribute("stopWords");
-		Set<String> stopWordsSet=null;
+    Set<String> stopWordsSet = null;
-		if((stopWords!=null)&&(fields!=null))
-		{
+    if ((stopWords != null) && (fields != null)) {
-		    stopWordsSet=new HashSet<String>();
+      stopWordsSet = new HashSet<String>();
-		    for (int i = 0; i < fields.length; i++)
-            {
-                try
-                {
-                  TokenStream ts = analyzer.reusableTokenStream(fields[i],new StringReader(stopWords));
+      for (String field : fields) {
+        try {
+          TokenStream ts = analyzer.reusableTokenStream(field, new StringReader(stopWords));
-                  CharTermAttribute termAtt = ts.addAttribute(CharTermAttribute.class);
-                  ts.reset();
+          CharTermAttribute termAtt = ts.addAttribute(CharTermAttribute.class);
+          ts.reset();
-	                while(ts.incrementToken()) {
+          while (ts.incrementToken()) {
-	                    stopWordsSet.add(termAtt.toString());
-	                }
-	                ts.end();
-	                ts.close();
-                }
+            stopWordsSet.add(termAtt.toString());
+          }
+          ts.end();
+          ts.close();
+        }
-                catch(IOException ioe)
-                {
+        catch (IOException ioe) {
-                    throw new ParserException("IoException parsing stop words list in "
+          throw new ParserException("IoException parsing stop words list in "
-                            +getClass().getName()+":"+ioe.getLocalizedMessage());
+              + getClass().getName() + ":" + ioe.getLocalizedMessage());
-                }
-            }
-		}
-		
-		
+        }
+      }
+    }
+
+
-		MoreLikeThisQuery mlt=new MoreLikeThisQuery(DOMUtils.getText(e),fields,analyzer);
+    MoreLikeThisQuery mlt = new MoreLikeThisQuery(DOMUtils.getText(e), fields, analyzer);
-		mlt.setMaxQueryTerms(DOMUtils.getAttribute(e,"maxQueryTerms",defaultMaxQueryTerms));
-		mlt.setMinTermFrequency(DOMUtils.getAttribute(e,"minTermFrequency",defaultMinTermFrequency));
-		mlt.setPercentTermsToMatch(DOMUtils.getAttribute(e,"percentTermsToMatch",defaultPercentTermsToMatch)/100);
+    mlt.setMaxQueryTerms(DOMUtils.getAttribute(e, "maxQueryTerms", DEFAULT_MAX_QUERY_TERMS));
+    mlt.setMinTermFrequency(DOMUtils.getAttribute(e, "minTermFrequency", DEFAULT_MIN_TERM_FREQUENCY));
+    mlt.setPercentTermsToMatch(DOMUtils.getAttribute(e, "percentTermsToMatch", DEFAULT_PERCENT_TERMS_TO_MATCH) / 100);
-		mlt.setStopWords(stopWordsSet);
+    mlt.setStopWords(stopWordsSet);
-		int minDocFreq=DOMUtils.getAttribute(e,"minDocFreq",-1);
+    int minDocFreq = DOMUtils.getAttribute(e, "minDocFreq", -1);
-		if(minDocFreq>=0)
-		{
+    if (minDocFreq >= 0) {
-			mlt.setMinDocFreq(minDocFreq);
-		}
+      mlt.setMinDocFreq(minDocFreq);
+    }
 
-		mlt.setBoost(DOMUtils.getAttribute(e,"boost",1.0f));
+    mlt.setBoost(DOMUtils.getAttribute(e, "boost", 1.0f));
 
-		return mlt;
-	}
+    return mlt;
+  }
 
 
-
 }
Index: lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/QueryBuilder.java
===================================================================
--- lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/QueryBuilder.java	(revision 712922)
+++ lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/QueryBuilder.java	Thu Jul 14 16:58:10 NZST 2011
@@ -25,5 +25,4 @@
 public interface QueryBuilder {
 	
 	public Query getQuery(Element e) throws ParserException;
-
 }
Index: lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/CorePlusExtensionsParser.java
===================================================================
--- lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/CorePlusExtensionsParser.java	(revision 1145016)
+++ lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/CorePlusExtensionsParser.java	Thu Jul 14 16:58:10 NZST 2011
@@ -2,12 +2,7 @@
 
 import org.apache.lucene.analysis.Analyzer;
 import org.apache.lucene.queryparser.classic.QueryParser;
-import org.apache.lucene.xmlparser.builders.BooleanFilterBuilder;
-import org.apache.lucene.xmlparser.builders.BoostingQueryBuilder;
-import org.apache.lucene.xmlparser.builders.DuplicateFilterBuilder;
-import org.apache.lucene.xmlparser.builders.FuzzyLikeThisQueryBuilder;
-import org.apache.lucene.xmlparser.builders.LikeThisQueryBuilder;
-import org.apache.lucene.xmlparser.builders.TermsFilterBuilder;
+import org.apache.lucene.xmlparser.builders.*;
 /**
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -26,41 +21,40 @@
  */
 
 /**
- * 
+ *
  */
-public class CorePlusExtensionsParser extends CoreParser
-{
+public class CorePlusExtensionsParser extends CoreParser {
 
-	/**
-	 * Construct an XML parser that uses a single instance QueryParser for handling 
-	 * UserQuery tags - all parse operations are synchronized on this parser
+  /**
+   * Construct an XML parser that uses a single instance QueryParser for handling
+   * UserQuery tags - all parse operations are synchronized on this parser
+   *
-	 * @param analyzer
-	 * @param parser A QueryParser which will be synchronized on during parse calls.
-	 */
+   * @param analyzer
+   * @param parser A QueryParser which will be synchronized on during parse calls.
+   */
-	public CorePlusExtensionsParser(Analyzer analyzer, QueryParser parser)
-	{
+  public CorePlusExtensionsParser(Analyzer analyzer, QueryParser parser) {
-		this(null,analyzer, parser);
+    this(null, analyzer, parser);
-	}
+  }
+
-	/**
-	 * Constructs an XML parser that creates a QueryParser for each UserQuery request.
+  /**
+   * Constructs an XML parser that creates a QueryParser for each UserQuery request.
+   *
-	 * @param defaultField The default field name used by QueryParsers constructed for UserQuery tags 
-	 * @param analyzer 
-	 */
+   * @param defaultField The default field name used by QueryParsers constructed for UserQuery tags
+   * @param analyzer
+   */
-	public CorePlusExtensionsParser(String defaultField,Analyzer analyzer)
-	{
+  public CorePlusExtensionsParser(String defaultField, Analyzer analyzer) {
-		this(defaultField,analyzer, null);
+    this(defaultField, analyzer, null);
-	}
+  }
 
-	private CorePlusExtensionsParser(String defaultField,Analyzer analyzer, QueryParser parser)
-	{
+  private CorePlusExtensionsParser(String defaultField, Analyzer analyzer, QueryParser parser) {
-		super(defaultField,analyzer, parser);
+    super(defaultField, analyzer, parser);
-		filterFactory.addBuilder("TermsFilter",new TermsFilterBuilder(analyzer));
+    filterFactory.addBuilder("TermsFilter", new TermsFilterBuilder(analyzer));
-		filterFactory.addBuilder("BooleanFilter",new BooleanFilterBuilder(filterFactory));
+    filterFactory.addBuilder("BooleanFilter", new BooleanFilterBuilder(filterFactory));
-		filterFactory.addBuilder("DuplicateFilter",new DuplicateFilterBuilder());
+    filterFactory.addBuilder("DuplicateFilter", new DuplicateFilterBuilder());
-		String fields[]={"contents"};
+    String fields[] = {"contents"};
-		queryFactory.addBuilder("LikeThisQuery",new LikeThisQueryBuilder(analyzer,fields));
+    queryFactory.addBuilder("LikeThisQuery", new LikeThisQueryBuilder(analyzer, fields));
-		queryFactory.addBuilder("BoostingQuery", new BoostingQueryBuilder(queryFactory));
-		queryFactory.addBuilder("FuzzyLikeThisQuery", new FuzzyLikeThisQueryBuilder(analyzer));
+    queryFactory.addBuilder("BoostingQuery", new BoostingQueryBuilder(queryFactory));
+    queryFactory.addBuilder("FuzzyLikeThisQuery", new FuzzyLikeThisQueryBuilder(analyzer));
 		
 	}
 }
Index: lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/QueryTemplateManager.java
===================================================================
--- lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/QueryTemplateManager.java	(revision 917019)
+++ lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/QueryTemplateManager.java	Thu Jul 14 16:58:10 NZST 2011
@@ -1,29 +1,23 @@
 package org.apache.lucene.xmlparser;
 
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.util.Enumeration;
-import java.util.HashMap;
-import java.util.Properties;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.xml.sax.SAXException;
 
 import javax.xml.parsers.DocumentBuilder;
 import javax.xml.parsers.DocumentBuilderFactory;
 import javax.xml.parsers.ParserConfigurationException;
-import javax.xml.transform.Result;
-import javax.xml.transform.Templates;
-import javax.xml.transform.Transformer;
-import javax.xml.transform.TransformerConfigurationException;
-import javax.xml.transform.TransformerException;
-import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.*;
 import javax.xml.transform.dom.DOMResult;
 import javax.xml.transform.dom.DOMSource;
 import javax.xml.transform.stream.StreamResult;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.Properties;
 
-import org.w3c.dom.Document;
-import org.w3c.dom.Element;
-import org.xml.sax.SAXException;
-
 /**
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -40,171 +34,168 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 /**
- * Provides utilities for turning query form input (such as from a web page or Swing gui) into 
- * Lucene XML queries by using XSL templates.  This approach offers a convenient way of externalizing 
- * and changing how user input is turned into Lucene queries. 
+ * Provides utilities for turning query form input (such as from a web page or Swing gui) into
+ * Lucene XML queries by using XSL templates.  This approach offers a convenient way of externalizing
+ * and changing how user input is turned into Lucene queries.
  * Database applications often adopt similar practices by externalizing SQL in template files that can
- * be easily changed/optimized by a DBA.  
- * The static methods can be used on their own or by creating an instance of this class you can store and 
+ * be easily changed/optimized by a DBA.
+ * The static methods can be used on their own or by creating an instance of this class you can store and
  * re-use compiled stylesheets for fast use (e.g. in a server environment)
  */
-public class QueryTemplateManager
-{
-	static DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance ();
-	static TransformerFactory tFactory = TransformerFactory.newInstance();
+public class QueryTemplateManager {
+  static final DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
+  static final TransformerFactory tFactory = TransformerFactory.newInstance();
 
-	HashMap<String,Templates> compiledTemplatesCache=new HashMap<String,Templates>();
+  HashMap<String, Templates> compiledTemplatesCache = new HashMap<String, Templates>();
-	Templates defaultCompiledTemplates=null;
+  Templates defaultCompiledTemplates = null;
 
-	
+
-	public QueryTemplateManager()
-	{
+  public QueryTemplateManager() {
-		
-	}
+
+  }
-	public QueryTemplateManager(InputStream xslIs) throws TransformerConfigurationException, ParserConfigurationException, SAXException, IOException
-	{
+
+  public QueryTemplateManager(InputStream xslIs)
+      throws TransformerConfigurationException, ParserConfigurationException, SAXException, IOException {
-		addDefaultQueryTemplate(xslIs);
-	}
+    addDefaultQueryTemplate(xslIs);
+  }
-	public void addDefaultQueryTemplate(InputStream xslIs) throws TransformerConfigurationException, ParserConfigurationException, SAXException, IOException
-	{
+
+  public void addDefaultQueryTemplate(InputStream xslIs)
+      throws TransformerConfigurationException, ParserConfigurationException, SAXException, IOException {
-		defaultCompiledTemplates=getTemplates(xslIs);
+    defaultCompiledTemplates = getTemplates(xslIs);
-	}
+  }
-	public void addQueryTemplate(String name, InputStream xslIs) throws TransformerConfigurationException, ParserConfigurationException, SAXException, IOException
-	{
+
+  public void addQueryTemplate(String name, InputStream xslIs)
+      throws TransformerConfigurationException, ParserConfigurationException, SAXException, IOException {
-		compiledTemplatesCache.put(name,getTemplates(xslIs));
+    compiledTemplatesCache.put(name, getTemplates(xslIs));
-	}
+  }
-	public String getQueryAsXmlString(Properties formProperties,String queryTemplateName) throws SAXException, IOException, ParserConfigurationException, TransformerException
-	{
+
+  public String getQueryAsXmlString(Properties formProperties, String queryTemplateName)
+      throws SAXException, IOException, ParserConfigurationException, TransformerException {
-		Templates ts= compiledTemplatesCache.get(queryTemplateName);
+    Templates ts = compiledTemplatesCache.get(queryTemplateName);
-		return getQueryAsXmlString(formProperties, ts);
-	}
-	
+    return getQueryAsXmlString(formProperties, ts);
+  }
+
-	public Document getQueryAsDOM(Properties formProperties,String queryTemplateName) throws SAXException, IOException, ParserConfigurationException, TransformerException
-	{
+  public Document getQueryAsDOM(Properties formProperties, String queryTemplateName)
+      throws SAXException, IOException, ParserConfigurationException, TransformerException {
-		Templates ts= compiledTemplatesCache.get(queryTemplateName);
+    Templates ts = compiledTemplatesCache.get(queryTemplateName);
-		return getQueryAsDOM(formProperties, ts);
-	}
+    return getQueryAsDOM(formProperties, ts);
+  }
-	public String getQueryAsXmlString(Properties formProperties) throws SAXException, IOException, ParserConfigurationException, TransformerException
-	{
+
+  public String getQueryAsXmlString(Properties formProperties)
+      throws SAXException, IOException, ParserConfigurationException, TransformerException {
-		return getQueryAsXmlString(formProperties, defaultCompiledTemplates);
-	}
-	
+    return getQueryAsXmlString(formProperties, defaultCompiledTemplates);
+  }
+
-	public Document getQueryAsDOM(Properties formProperties) throws SAXException, IOException, ParserConfigurationException, TransformerException
-	{
+  public Document getQueryAsDOM(Properties formProperties)
+      throws SAXException, IOException, ParserConfigurationException, TransformerException {
-		return getQueryAsDOM(formProperties, defaultCompiledTemplates);
-	}
-	
+    return getQueryAsDOM(formProperties, defaultCompiledTemplates);
+  }
+
-	
-	/**
-	 * Fast means of constructing query using a precompiled stylesheet  
-	 */		
+  /**
+   * Fast means of constructing query using a precompiled stylesheet
+   */
-	public static String getQueryAsXmlString(Properties formProperties, Templates template) throws SAXException, IOException, ParserConfigurationException, TransformerException 
-	{
+  public static String getQueryAsXmlString(Properties formProperties, Templates template)
+      throws SAXException, IOException, ParserConfigurationException, TransformerException {
-  		ByteArrayOutputStream baos=new ByteArrayOutputStream();
+    ByteArrayOutputStream baos = new ByteArrayOutputStream();
-  		StreamResult result=new StreamResult(baos);
+    StreamResult result = new StreamResult(baos);
-  		transformCriteria(formProperties,template,result);
+    transformCriteria(formProperties, template, result);
-  		return baos.toString();  		
-	}
-	
-	/**
-	 * Slow means of constructing query parsing a stylesheet from an input stream  
-	 */		
+    return baos.toString();
+  }
+
+  /**
+   * Slow means of constructing query parsing a stylesheet from an input stream
+   */
-	public static String getQueryAsXmlString(Properties formProperties, InputStream xslIs) throws SAXException, IOException, ParserConfigurationException, TransformerException 
-	{
+  public static String getQueryAsXmlString(Properties formProperties, InputStream xslIs)
+      throws SAXException, IOException, ParserConfigurationException, TransformerException {
-  		ByteArrayOutputStream baos=new ByteArrayOutputStream();
+    ByteArrayOutputStream baos = new ByteArrayOutputStream();
-  		StreamResult result=new StreamResult(baos);
+    StreamResult result = new StreamResult(baos);
-  		transformCriteria(formProperties,xslIs,result);
+    transformCriteria(formProperties, xslIs, result);
-  		return baos.toString();  		
-	}
-			
+    return baos.toString();
+  }
+
 
-	/**
-	 * Fast means of constructing query using a cached,precompiled stylesheet  
-	 */	
+  /**
+   * Fast means of constructing query using a cached,precompiled stylesheet
+   */
-	public static Document getQueryAsDOM(Properties formProperties, Templates template) throws SAXException, IOException, ParserConfigurationException, TransformerException
-	{
+  public static Document getQueryAsDOM(Properties formProperties, Templates template)
+      throws SAXException, IOException, ParserConfigurationException, TransformerException {
-  		DOMResult result=new DOMResult();
+    DOMResult result = new DOMResult();
-  		transformCriteria(formProperties,template,result);
+    transformCriteria(formProperties, template, result);
-  		return (Document)result.getNode();
+    return (Document) result.getNode();
-	}
+  }
 
-	
-	/**
-	 * Slow means of constructing query - parses stylesheet from input stream 
-	 */
+
+  /**
+   * Slow means of constructing query - parses stylesheet from input stream
+   */
-	public static Document getQueryAsDOM(Properties formProperties, InputStream xslIs) throws SAXException, IOException, ParserConfigurationException, TransformerException
-	{
+  public static Document getQueryAsDOM(Properties formProperties, InputStream xslIs)
+      throws SAXException, IOException, ParserConfigurationException, TransformerException {
-  		DOMResult result=new DOMResult();
+    DOMResult result = new DOMResult();
-  		transformCriteria(formProperties,xslIs,result);
+    transformCriteria(formProperties, xslIs, result);
-  		return (Document)result.getNode();
+    return (Document) result.getNode();
-	}
-	
-	
+  }
+
+
-	
-	
-	/**
-	 * Slower transformation using an uncompiled stylesheet (suitable for development environment)
-	 */
+  /**
+   * Slower transformation using an uncompiled stylesheet (suitable for development environment)
+   */
-	public static void transformCriteria(Properties formProperties, InputStream xslIs, Result result) throws SAXException, IOException, ParserConfigurationException, TransformerException
-	{
+  public static void transformCriteria(Properties formProperties, InputStream xslIs, Result result)
+      throws SAXException, IOException, ParserConfigurationException, TransformerException {
-        dbf.setNamespaceAware(true);	    
-		DocumentBuilder builder = dbf.newDocumentBuilder();
-		org.w3c.dom.Document xslDoc = builder.parse(xslIs);
-		DOMSource ds = new DOMSource(xslDoc);
-		
+    dbf.setNamespaceAware(true);
+    DocumentBuilder builder = dbf.newDocumentBuilder();
+    org.w3c.dom.Document xslDoc = builder.parse(xslIs);
+    DOMSource ds = new DOMSource(xslDoc);
+
-		Transformer transformer =null;
+    Transformer transformer = null;
-		synchronized (tFactory)
-		{
+    synchronized (tFactory) {
-			transformer = tFactory.newTransformer(ds);			
-		}
+      transformer = tFactory.newTransformer(ds);
+    }
-		transformCriteria(formProperties,transformer,result);
+    transformCriteria(formProperties, transformer, result);
-	}
-	
-	/**
-	 * Fast transformation using a pre-compiled stylesheet (suitable for production environments)
-	 */
+  }
+
+  /**
+   * Fast transformation using a pre-compiled stylesheet (suitable for production environments)
+   */
-	public static void transformCriteria(Properties formProperties, Templates template, Result result) throws SAXException, IOException, ParserConfigurationException, TransformerException
-	{
+  public static void transformCriteria(Properties formProperties, Templates template, Result result)
+      throws SAXException, IOException, ParserConfigurationException, TransformerException {
-		transformCriteria(formProperties,template.newTransformer(),result);
+    transformCriteria(formProperties, template.newTransformer(), result);
-	}
-	
-	
+  }
+
+
-	
-	public static void transformCriteria(Properties formProperties, Transformer transformer, Result result) throws SAXException, IOException, ParserConfigurationException, TransformerException
-	{
+  public static void transformCriteria(Properties formProperties, Transformer transformer, Result result)
+      throws SAXException, IOException, ParserConfigurationException, TransformerException {
-        dbf.setNamespaceAware(true);
-        
-	    //Create an XML document representing the search index document.
+    dbf.setNamespaceAware(true);
+
+    //Create an XML document representing the search index document.
-		DocumentBuilder db = dbf.newDocumentBuilder ();
+    DocumentBuilder db = dbf.newDocumentBuilder();
-		org.w3c.dom.Document doc = db.newDocument ();
+    org.w3c.dom.Document doc = db.newDocument();
-		Element root = doc.createElement ("Document");
+    Element root = doc.createElement("Document");
-		doc.appendChild (root);
+    doc.appendChild(root);
-		
-		Enumeration keysEnum = formProperties.keys();
+
+    Enumeration keysEnum = formProperties.keys();
-		while(keysEnum.hasMoreElements())
-		{
+    while (keysEnum.hasMoreElements()) {
-		    String propName=(String) keysEnum.nextElement();
+      String propName = (String) keysEnum.nextElement();
-		    String value=formProperties.getProperty(propName);
+      String value = formProperties.getProperty(propName);
-    		if((value!=null)&&(value.length()>0))
-    		{
+      if ((value != null) && (value.length() > 0)) {
-    		    DOMUtils.insertChild(root,propName,value);    			
+        DOMUtils.insertChild(root, propName, value);
-    		}
-		}		
-		//Use XSLT to to transform into an XML query string using the  queryTemplate
+      }
+    }
+    //Use XSLT to to transform into an XML query string using the  queryTemplate
-		DOMSource xml=new DOMSource(doc);
+    DOMSource xml = new DOMSource(doc);
-		transformer.transform(xml,result);		
+    transformer.transform(xml, result);
-	}
-	
-	/**
-	 * Parses a query stylesheet for repeated use
-	 */
+  }
+
+  /**
+   * Parses a query stylesheet for repeated use
+   */
-	public static Templates getTemplates(InputStream xslIs) throws ParserConfigurationException, SAXException, IOException, TransformerConfigurationException  
-	{
+  public static Templates getTemplates(InputStream xslIs)
+      throws ParserConfigurationException, SAXException, IOException, TransformerConfigurationException {
-        dbf.setNamespaceAware(true);	    
-		DocumentBuilder builder = dbf.newDocumentBuilder();
-		org.w3c.dom.Document xslDoc = builder.parse(xslIs);
-		DOMSource ds = new DOMSource(xslDoc);
-		return tFactory.newTemplates(ds);
+    dbf.setNamespaceAware(true);
+    DocumentBuilder builder = dbf.newDocumentBuilder();
+    org.w3c.dom.Document xslDoc = builder.parse(xslIs);
+    DOMSource ds = new DOMSource(xslDoc);
+    return tFactory.newTemplates(ds);
 	}
 }
Index: lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/DOMUtils.java
===================================================================
--- lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/DOMUtils.java	(revision 821185)
+++ lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/DOMUtils.java	Thu Jul 14 16:58:10 NZST 2011
@@ -1,13 +1,13 @@
 package org.apache.lucene.xmlparser;
-import java.io.Reader;
 
-import javax.xml.parsers.DocumentBuilder;
-import javax.xml.parsers.DocumentBuilderFactory;
-
 import org.w3c.dom.Document;
 import org.w3c.dom.Element;
 import org.w3c.dom.Node;
 import org.xml.sax.InputSource;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import java.io.Reader;
 /**
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -26,253 +26,192 @@
  */
 
 /**
- * 
+ *
  */
-public class DOMUtils
-{
-    public static Element getChildByTagOrFail(Element e, String name)	throws ParserException
-	{
+public class DOMUtils {
+
+  public static Element getChildByTagOrFail(Element e, String name) throws ParserException {
-		Element kid = getChildByTagName(e, name);
+    Element kid = getChildByTagName(e, name);
-		if (null == kid)
-		{
+    if (null == kid) {
-			throw new ParserException(e.getTagName() + " missing \"" + name
-					+ "\" child element");
-		}
-		return kid;
-	}
-     
+      throw new ParserException(e.getTagName() + " missing \"" + name
+          + "\" child element");
+    }
+    return kid;
+  }
+
-     public static Element getFirstChildOrFail(Element e) throws ParserException
-	{
+  public static Element getFirstChildOrFail(Element e) throws ParserException {
-		Element kid = getFirstChildElement(e);
+    Element kid = getFirstChildElement(e);
-		if (null == kid)
-		{
+    if (null == kid) {
-			throw new ParserException(e.getTagName()
-					+ " does not contain a child element");
-		}
-		return kid;
-	}
-     
+      throw new ParserException(e.getTagName()
+          + " does not contain a child element");
+    }
+    return kid;
+  }
+
-	public static String getAttributeOrFail(Element e, String name)	throws ParserException
-	{
+  public static String getAttributeOrFail(Element e, String name) throws ParserException {
-		String v = e.getAttribute(name);
+    String v = e.getAttribute(name);
-		if (null == v)
-		{
+    if (null == v) {
-			throw new ParserException(e.getTagName() + " missing \"" + name
-					+ "\" attribute");
-		}
-		return v;
-	}
+      throw new ParserException(e.getTagName() + " missing \"" + name
+          + "\" attribute");
+    }
+    return v;
+  }
-    public static String getAttributeWithInheritanceOrFail(Element e,	String name) throws ParserException
-	{
+
+  public static String getAttributeWithInheritanceOrFail(Element e, String name) throws ParserException {
-		String v = getAttributeWithInheritance(e, name);
+    String v = getAttributeWithInheritance(e, name);
-		if (null == v)
-		{
+    if (null == v) {
-			throw new ParserException(e.getTagName() + " missing \"" + name
-					+ "\" attribute");
-		}
-		return v;
-	}
+      throw new ParserException(e.getTagName() + " missing \"" + name
+          + "\" attribute");
+    }
+    return v;
+  }
-    public static String getNonBlankTextOrFail(Element e) throws ParserException
-	{
+
+  public static String getNonBlankTextOrFail(Element e) throws ParserException {
-		String v = getText(e);
-		if (null != v)
-			v = v.trim();
+    String v = getText(e);
+    if (null != v)
+      v = v.trim();
-		if (null == v || 0 == v.length())
-		{
+    if (null == v || 0 == v.length()) {
-			throw new ParserException(e.getTagName() + " has no text");
-		}
-		return v;
-	}
- 
+      throw new ParserException(e.getTagName() + " has no text");
+    }
+    return v;
+  }
+
-     
-     
-     
-	
-	
-	/* Convenience method where there is only one child Element of a given name */
+  /* Convenience method where there is only one child Element of a given name */
-	public static Element getChildByTagName(Element e, String name)
-	{
-	       for (Node kid = e.getFirstChild(); kid != null; kid = kid.getNextSibling())
-		{
-			if( (kid.getNodeType()==Node.ELEMENT_NODE) && (name.equals(kid.getNodeName())) )
-			{
+  public static Element getChildByTagName(Element e, String name) {
+    for (Node kid = e.getFirstChild(); kid != null; kid = kid.getNextSibling()) {
+      if ((kid.getNodeType() == Node.ELEMENT_NODE) && (name.equals(kid.getNodeName()))) {
-				return (Element)kid;
+        return (Element) kid;
-			}
-		}
-		return null;
-	}
+      }
+    }
+    return null;
+  }
 
-	/**
-	 * Returns an attribute value from this node, or first parent node with this attribute defined
+  /**
+   * Returns an attribute value from this node, or first parent node with this attribute defined
+   *
-	 * @param element 
-	 * @param attributeName
-	 * @return A non-zero-length value if defined, otherwise null
-	 */
+   * @param element
+   * @param attributeName
+   * @return A non-zero-length value if defined, otherwise null
+   */
-	public static String getAttributeWithInheritance(Element element, String attributeName)
-	{
+  public static String getAttributeWithInheritance(Element element, String attributeName) {
-		String result=element.getAttribute(attributeName);
+    String result = element.getAttribute(attributeName);
-		if( (result==null)|| ("".equals(result) ) )
-		{
+    if ((result == null) || ("".equals(result))) {
-			Node n=element.getParentNode();
+      Node n = element.getParentNode();
-			if((n==element)||(n==null))
-			{
+      if ((n == element) || (n == null)) {
-				return null;
-			}
+        return null;
+      }
-			if(n instanceof Element)
-			{
+      if (n instanceof Element) {
-				Element parent=(Element) n;
+        Element parent = (Element) n;
-				return getAttributeWithInheritance(parent,attributeName);
+        return getAttributeWithInheritance(parent, attributeName);
-			}
-			return null; //we reached the top level of the document without finding attribute
-		}
-		return result;		
-	}
+      }
+      return null; //we reached the top level of the document without finding attribute
+    }
+    return result;
+  }
 
 
-
-	/* Convenience method where there is only one child Element of a given name */
+  /* Convenience method where there is only one child Element of a given name */
-	public static String getChildTextByTagName(Element e, String tagName)
-	{
+  public static String getChildTextByTagName(Element e, String tagName) {
-		Element child=getChildByTagName(e,tagName);
+    Element child = getChildByTagName(e, tagName);
-		if(child!=null)
-		{
-			return getText(child);
+    return child != null ? getText(child) : null;
-		}
+  }
-		return null;
-	}
 
-	/* Convenience method to append a new child with text*/
+  /* Convenience method to append a new child with text*/
-	public static Element insertChild(Element parent, String tagName, String text)
-	{
+  public static Element insertChild(Element parent, String tagName, String text) {
-	  	Element child = parent.getOwnerDocument().createElement(tagName);
-		parent.appendChild(child);
+    Element child = parent.getOwnerDocument().createElement(tagName);
+    parent.appendChild(child);
-		if(text!=null)
-		{
+    if (text != null) {
-		  	child.appendChild(child.getOwnerDocument().createTextNode(text));
-		}
-		return child;
-	}
+      child.appendChild(child.getOwnerDocument().createTextNode(text));
+    }
+    return child;
+  }
 
-	public static String getAttribute(Element element, String attributeName, String deflt)
-	{
+  public static String getAttribute(Element element, String attributeName, String deflt) {
-		String result=element.getAttribute(attributeName);
+    String result = element.getAttribute(attributeName);
-		if( (result==null)|| ("".equals(result) ) )
-		{
-			return deflt;
+    return (result == null) || ("".equals(result)) ? deflt : result;
-		}
+  }
-		return result;
-	}
-	public static float getAttribute(Element element, String attributeName, float deflt)
-	{
+
+  public static float getAttribute(Element element, String attributeName, float deflt) {
-		String result=element.getAttribute(attributeName);
+    String result = element.getAttribute(attributeName);
-		if( (result==null)|| ("".equals(result) ) )
-		{
-			return deflt;
+    return (result == null) || ("".equals(result)) ? deflt : Float.parseFloat(result);
-		}
+  }
-		return Float.parseFloat(result);
-	}	
 
-	public static int getAttribute(Element element, String attributeName, int deflt)
-	{
+  public static int getAttribute(Element element, String attributeName, int deflt) {
-		String result=element.getAttribute(attributeName);
+    String result = element.getAttribute(attributeName);
-		if( (result==null)|| ("".equals(result) ) )
-		{
-			return deflt;
+    return (result == null) || ("".equals(result)) ? deflt : Integer.parseInt(result);
-		}
+  }
-		return Integer.parseInt(result);
-	}
-	
-	public static boolean getAttribute(Element element, String attributeName,
+
+  public static boolean getAttribute(Element element, String attributeName,
-			boolean deflt)
-	{
+                                     boolean deflt) {
-		String result = element.getAttribute(attributeName);
+    String result = element.getAttribute(attributeName);
-		if ((result == null) || ("".equals(result)))
-		{
-			return deflt;
+    return (result == null) || ("".equals(result)) ? deflt : Boolean.valueOf(result);
-		}
+  }
-		return Boolean.valueOf(result).booleanValue();
-	}	
 
-	/* Returns text of node and all child nodes - without markup */
-	//MH changed to Node from Element 25/11/2005
+  /* Returns text of node and all child nodes - without markup */
+  //MH changed to Node from Element 25/11/2005
-	public static String getText(Node e)
-	{
+
+  public static String getText(Node e) {
-		StringBuilder sb=new StringBuilder();
+    StringBuilder sb = new StringBuilder();
-		getTextBuffer(e, sb);
-		return sb.toString();
-	}
-	
+    getTextBuffer(e, sb);
+    return sb.toString();
+  }
+
-	public static Element getFirstChildElement(Element element)
-	{
-		for (Node kid = element.getFirstChild(); kid != null; kid = kid
-				.getNextSibling())
-		{
-			if (kid.getNodeType() == Node.ELEMENT_NODE) 
-			{
+  public static Element getFirstChildElement(Element element) {
+    for (Node kid = element.getFirstChild(); kid != null; kid = kid.getNextSibling()) {
+      if (kid.getNodeType() == Node.ELEMENT_NODE) {
-				return (Element) kid;
-			}
-		}
-		return null;
-	}	
+        return (Element) kid;
+      }
+    }
+    return null;
+  }
 
-	private static void getTextBuffer(Node e, StringBuilder sb)
-	{
-	    for (Node kid = e.getFirstChild(); kid != null; kid = kid.getNextSibling())
-		{
-			switch(kid.getNodeType())
-			{
-				case Node.TEXT_NODE:
-				{
+  private static void getTextBuffer(Node e, StringBuilder sb) {
+    for (Node kid = e.getFirstChild(); kid != null; kid = kid.getNextSibling()) {
+      switch (kid.getNodeType()) {
+        case Node.TEXT_NODE: {
-					sb.append(kid.getNodeValue());
-					break;
-				}
+          sb.append(kid.getNodeValue());
+          break;
+        }
-				case Node.ELEMENT_NODE:
-				{
+        case Node.ELEMENT_NODE: {
-					getTextBuffer(kid, sb);
-					break;
-				}
+          getTextBuffer(kid, sb);
+          break;
+        }
-				case Node.ENTITY_REFERENCE_NODE:
-				{
+        case Node.ENTITY_REFERENCE_NODE: {
-					getTextBuffer(kid, sb);
-					break;
-				}
-			}
-		}
-	}
+          getTextBuffer(kid, sb);
+          break;
+        }
+      }
+    }
+  }
 
-	/**
-	* Helper method to parse an XML file into a DOM tree, given a reader.
+  /**
+   * Helper method to parse an XML file into a DOM tree, given a reader.
+   *
-	* @param is reader of the XML file to be parsed
-	* @return an org.w3c.dom.Document object
-	*/
+   * @param is reader of the XML file to be parsed
+   * @return an org.w3c.dom.Document object
+   */
-	public static Document loadXML(Reader is)
-	{
-
+  public static Document loadXML(Reader is) {
-		DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
-		DocumentBuilder db = null;
-		
+    DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
+    DocumentBuilder db = null;
+
-		try
-		{
+    try {
-			db = dbf.newDocumentBuilder();
-		}
+      db = dbf.newDocumentBuilder();
+    }
-		catch (Exception se)
-		{
+    catch (Exception se) {
-			throw new RuntimeException("Parser configuration error", se);
-		}
+      throw new RuntimeException("Parser configuration error", se);
+    }
 
-		// Step 3: parse the input file
-		org.w3c.dom.Document doc = null;
+    // Step 3: parse the input file
+    org.w3c.dom.Document doc = null;
-		try
-		{
+    try {
-			doc = db.parse(new InputSource(is));
-			//doc = db.parse(is);
-		}
+      doc = db.parse(new InputSource(is));
+      //doc = db.parse(is);
+    }
-		catch (Exception se)
-		{
+    catch (Exception se) {
-			throw new RuntimeException("Error parsing file:" + se, se);
-		}
+      throw new RuntimeException("Error parsing file:" + se, se);
+    }
 
-		return doc;
+    return doc;
 	}	
 }
 
Index: lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/TermQueryBuilder.java
===================================================================
--- lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/TermQueryBuilder.java	(revision 811070)
+++ lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/TermQueryBuilder.java	Thu Jul 14 17:15:25 NZST 2011
@@ -25,19 +25,16 @@
  */
 
 /**
- * 
+ *
  */
 public class TermQueryBuilder implements QueryBuilder {
 
-	public Query getQuery(Element e) throws ParserException {
+  public Query getQuery(Element e) throws ParserException {
-		
-        String field=DOMUtils.getAttributeWithInheritanceOrFail(e,"fieldName");
+    String field = DOMUtils.getAttributeWithInheritanceOrFail(e, "fieldName");
- 		String value=DOMUtils.getNonBlankTextOrFail(e);
+    String value = DOMUtils.getNonBlankTextOrFail(e);
-  		TermQuery tq = new TermQuery(new Term(field,value));
+    TermQuery tq = new TermQuery(new Term(field, value));
-  		tq.setBoost(DOMUtils.getAttribute(e,"boost",1.0f));
+    tq.setBoost(DOMUtils.getAttribute(e, "boost", 1.0f));
-
-  		return tq;
+    return tq;
-		
-	}
+  }
 
 }
Index: lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/MatchAllDocsQueryBuilder.java
===================================================================
--- lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/MatchAllDocsQueryBuilder.java	(revision 811070)
+++ lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/MatchAllDocsQueryBuilder.java	Thu Jul 14 17:08:04 NZST 2011
@@ -23,12 +23,11 @@
  */
 
 /**
- * 
+ *
  */
-public class MatchAllDocsQueryBuilder implements QueryBuilder
-{
-	public Query getQuery(Element e) throws ParserException
-	{
+public class MatchAllDocsQueryBuilder implements QueryBuilder {
+  
+  public Query getQuery(Element e) throws ParserException {
-		return new MatchAllDocsQuery();
-	}
+    return new MatchAllDocsQuery();
+  }
 }
Index: lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/NumericRangeQueryBuilder.java
===================================================================
--- lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/NumericRangeQueryBuilder.java	(revision 1003877)
+++ lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/NumericRangeQueryBuilder.java	Thu Jul 14 17:15:25 NZST 2011
@@ -80,48 +80,46 @@
  * <td>4</td>
  * </tr>
  * </table>
- * <p>
+ * <p/>
  * A {@link ParserException} will be thrown if an error occurs parsing the
  * supplied <tt>lowerTerm</tt> or <tt>upperTerm</tt> into the numeric type
  * specified by <tt>type</tt>.
  */
 public class NumericRangeQueryBuilder implements QueryBuilder {
 
-	public Query getQuery(Element e) throws ParserException {
-		String field = DOMUtils.getAttributeWithInheritanceOrFail(e, "fieldName");
-		String lowerTerm = DOMUtils.getAttributeOrFail(e, "lowerTerm");
-		String upperTerm = DOMUtils.getAttributeOrFail(e, "upperTerm");
-		boolean lowerInclusive = DOMUtils.getAttribute(e, "includeLower", true);
-		boolean upperInclusive = DOMUtils.getAttribute(e, "includeUpper", true);
-		int precisionStep = DOMUtils.getAttribute(e, "precisionStep", NumericUtils.PRECISION_STEP_DEFAULT);
+  public Query getQuery(Element e) throws ParserException {
+    String field = DOMUtils.getAttributeWithInheritanceOrFail(e, "fieldName");
+    String lowerTerm = DOMUtils.getAttributeOrFail(e, "lowerTerm");
+    String upperTerm = DOMUtils.getAttributeOrFail(e, "upperTerm");
+    boolean lowerInclusive = DOMUtils.getAttribute(e, "includeLower", true);
+    boolean upperInclusive = DOMUtils.getAttribute(e, "includeUpper", true);
+    int precisionStep = DOMUtils.getAttribute(e, "precisionStep", NumericUtils.PRECISION_STEP_DEFAULT);
 
-		String type = DOMUtils.getAttribute(e, "type", "int");
-		try {
-			Query filter;
-			if (type.equalsIgnoreCase("int")) {
-				filter = NumericRangeQuery.newIntRange(field, precisionStep, Integer
-						.valueOf(lowerTerm), Integer.valueOf(upperTerm), lowerInclusive,
-						upperInclusive);
-			} else if (type.equalsIgnoreCase("long")) {
-				filter = NumericRangeQuery.newLongRange(field, precisionStep, Long
-						.valueOf(lowerTerm), Long.valueOf(upperTerm), lowerInclusive,
-						upperInclusive);
-			} else if (type.equalsIgnoreCase("double")) {
-				filter = NumericRangeQuery.newDoubleRange(field, precisionStep, Double
-						.valueOf(lowerTerm), Double.valueOf(upperTerm), lowerInclusive,
-						upperInclusive);
-			} else if (type.equalsIgnoreCase("float")) {
-				filter = NumericRangeQuery.newFloatRange(field, precisionStep, Float
-						.valueOf(lowerTerm), Float.valueOf(upperTerm), lowerInclusive,
-						upperInclusive);
-			} else {
+    String type = DOMUtils.getAttribute(e, "type", "int");
+    try {
+      Query filter;
+      if (type.equalsIgnoreCase("int")) {
+        filter = NumericRangeQuery.newIntRange(field, precisionStep, Integer
+            .valueOf(lowerTerm), Integer.valueOf(upperTerm), lowerInclusive,
+            upperInclusive);
+      } else if (type.equalsIgnoreCase("long")) {
+        filter = NumericRangeQuery.newLongRange(field, precisionStep, Long
+            .valueOf(lowerTerm), Long.valueOf(upperTerm), lowerInclusive,
+            upperInclusive);
+      } else if (type.equalsIgnoreCase("double")) {
+        filter = NumericRangeQuery.newDoubleRange(field, precisionStep, Double
+            .valueOf(lowerTerm), Double.valueOf(upperTerm), lowerInclusive,
+            upperInclusive);
+      } else if (type.equalsIgnoreCase("float")) {
+        filter = NumericRangeQuery.newFloatRange(field, precisionStep, Float
+            .valueOf(lowerTerm), Float.valueOf(upperTerm), lowerInclusive,
+            upperInclusive);
+      } else {
-				throw new ParserException(
-						"type attribute must be one of: [long, int, double, float]");
+        throw new ParserException("type attribute must be one of: [long, int, double, float]");
-			}
-			return filter;
-		} catch (NumberFormatException nfe) {
+      }
+      return filter;
+    } catch (NumberFormatException nfe) {
-			throw new ParserException(
-					"Could not parse lowerTerm or upperTerm into a number", nfe);
+      throw new ParserException("Could not parse lowerTerm or upperTerm into a number", nfe);
-		}
-	}
+    }
+  }
 }
Index: lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/BooleanFilterBuilder.java
===================================================================
--- lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/BooleanFilterBuilder.java	(revision 811070)
+++ lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/BooleanFilterBuilder.java	Thu Jul 14 16:59:05 NZST 2011
@@ -32,36 +32,33 @@
  */
 
 /**
- * 
+ *
  */
 public class BooleanFilterBuilder implements FilterBuilder {
-	
+
-	private FilterBuilder factory;
+  private final FilterBuilder factory;
 
-	public BooleanFilterBuilder(FilterBuilder factory)
-	{
+  public BooleanFilterBuilder(FilterBuilder factory) {
-		this.factory=factory;
+    this.factory = factory;
-	}
+  }
 
-	public Filter getFilter(Element e) throws ParserException {
+  public Filter getFilter(Element e) throws ParserException {
-		BooleanFilter bf=new BooleanFilter();
+    BooleanFilter bf = new BooleanFilter();
-		NodeList nl = e.getChildNodes();
-		
+    NodeList nl = e.getChildNodes();
+
-		for(int i=0;i<nl.getLength();i++)
-		{
+    for (int i = 0; i < nl.getLength(); i++) {
-			Node node = nl.item(i);
+      Node node = nl.item(i);
-			if(node.getNodeName().equals("Clause"))
-			{
+      if (node.getNodeName().equals("Clause")) {
-				Element clauseElem=(Element) node;
+        Element clauseElem = (Element) node;
-				BooleanClause.Occur occurs=BooleanQueryBuilder.getOccursValue(clauseElem);
+        BooleanClause.Occur occurs = BooleanQueryBuilder.getOccursValue(clauseElem);
-			
+
-	 			Element clauseFilter=DOMUtils.getFirstChildOrFail(clauseElem);
+        Element clauseFilter = DOMUtils.getFirstChildOrFail(clauseElem);
-	 			Filter f=factory.getFilter(clauseFilter);
+        Filter f = factory.getFilter(clauseFilter);
-	 			bf.add(new FilterClause(f,occurs));
+        bf.add(new FilterClause(f, occurs));
-			}
-		}
-		
-		return bf;
-	}
+      }
+    }
+
+    return bf;
+  }
 
 }
Index: lucene/contrib/xml-query-parser/src/demo/java/org/apache/lucene/xmlparser/webdemo/FormBasedXmlQueryDemo.java
===================================================================
--- lucene/contrib/xml-query-parser/src/demo/java/org/apache/lucene/xmlparser/webdemo/FormBasedXmlQueryDemo.java	(revision 1044835)
+++ lucene/contrib/xml-query-parser/src/demo/java/org/apache/lucene/xmlparser/webdemo/FormBasedXmlQueryDemo.java	Thu Jul 14 17:37:27 NZST 2011
@@ -17,21 +17,6 @@
 
 package org.apache.lucene.xmlparser.webdemo;
 
-import java.io.BufferedReader;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.util.Enumeration;
-import java.util.Properties;
-import java.util.StringTokenizer;
-
-import javax.servlet.RequestDispatcher;
-import javax.servlet.ServletConfig;
-import javax.servlet.ServletException;
-import javax.servlet.http.HttpServlet;
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
-
 import org.apache.lucene.analysis.Analyzer;
 import org.apache.lucene.analysis.standard.StandardAnalyzer;
 import org.apache.lucene.document.Document;
@@ -48,108 +33,118 @@
 import org.apache.lucene.xmlparser.CorePlusExtensionsParser;
 import org.apache.lucene.xmlparser.QueryTemplateManager;
 
+import javax.servlet.RequestDispatcher;
+import javax.servlet.ServletConfig;
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.Enumeration;
+import java.util.Properties;
+import java.util.StringTokenizer;
+
 public class FormBasedXmlQueryDemo extends HttpServlet {
 
-	private QueryTemplateManager queryTemplateManager;
-	private CorePlusExtensionsParser xmlParser;
-	private IndexSearcher searcher;
+  private QueryTemplateManager queryTemplateManager;
+  private CorePlusExtensionsParser xmlParser;
+  private IndexSearcher searcher;
-	private Analyzer analyzer=new StandardAnalyzer(org.apache.lucene.util.Version.LUCENE_CURRENT);
+  private Analyzer analyzer = new StandardAnalyzer(org.apache.lucene.util.Version.LUCENE_CURRENT);
 
-	@Override
-	public void init(ServletConfig config) throws ServletException {
-		super.init(config);
-		try {
-			openExampleIndex();
+  @Override
+  public void init(ServletConfig config) throws ServletException {
+    super.init(config);
+    try {
+      openExampleIndex();
 
-			//load servlet configuration settings
+      //load servlet configuration settings
-			String xslFile=config.getInitParameter("xslFile");
+      String xslFile = config.getInitParameter("xslFile");
-			String defaultStandardQueryParserField = config.getInitParameter("defaultStandardQueryParserField");
+      String defaultStandardQueryParserField = config.getInitParameter("defaultStandardQueryParserField");
 
 
-			//Load and cache choice of XSL query template using QueryTemplateManager
+      //Load and cache choice of XSL query template using QueryTemplateManager
-			queryTemplateManager=new QueryTemplateManager(
+      queryTemplateManager = new QueryTemplateManager(
-					getServletContext().getResourceAsStream("/WEB-INF/"+xslFile));
+          getServletContext().getResourceAsStream("/WEB-INF/" + xslFile));
 
-			//initialize an XML Query Parser for use by all threads
+      //initialize an XML Query Parser for use by all threads
-			xmlParser=new CorePlusExtensionsParser(defaultStandardQueryParserField,analyzer);
+      xmlParser = new CorePlusExtensionsParser(defaultStandardQueryParserField, analyzer);
-		} catch (Exception e) {
+    } catch (Exception e) {
-			throw new ServletException("Error loading query template",e);
+      throw new ServletException("Error loading query template", e);
-		}
-	}
+    }
+  }
 
-	@Override
-	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-		//Take all completed form fields and add to a Properties object
+  @Override
+  protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+    //Take all completed form fields and add to a Properties object
-		Properties completedFormFields=new Properties();
+    Properties completedFormFields = new Properties();
-		Enumeration pNames = request.getParameterNames();
+    Enumeration pNames = request.getParameterNames();
-		while(pNames.hasMoreElements()){
+    while (pNames.hasMoreElements()) {
-			String propName=(String) pNames.nextElement();
+      String propName = (String) pNames.nextElement();
-			String value=request.getParameter(propName);
+      String value = request.getParameter(propName);
-			if((value!=null)&&(value.trim().length()>0)){
+      if ((value != null) && (value.trim().length() > 0)) {
-				completedFormFields.setProperty(propName, value);
-			}
-		}
+        completedFormFields.setProperty(propName, value);
+      }
+    }
 
-		try{
+    try {
-
-			//Create an XML query by populating template with given user criteria
+      //Create an XML query by populating template with given user criteria
-			org.w3c.dom.Document xmlQuery=queryTemplateManager.getQueryAsDOM(completedFormFields);
+      org.w3c.dom.Document xmlQuery = queryTemplateManager.getQueryAsDOM(completedFormFields);
 
-			//Parse the XML to produce a Lucene query
+      //Parse the XML to produce a Lucene query
-			Query query=xmlParser.getQuery(xmlQuery.getDocumentElement());
+      Query query = xmlParser.getQuery(xmlQuery.getDocumentElement());
 
-			//Run the query
+      //Run the query
-			TopDocs topDocs = searcher.search(query,10);
+      TopDocs topDocs = searcher.search(query, 10);
 
-			//and package the results and forward to JSP
+      //and package the results and forward to JSP
-			if(topDocs!=null)	{
+      if (topDocs != null) {
-				ScoreDoc[] sd = topDocs.scoreDocs;
+        ScoreDoc[] sd = topDocs.scoreDocs;
-				Document[] results=new Document[sd.length];
+        Document[] results = new Document[sd.length];
-				for (int i = 0; i < results.length; i++) {
+        for (int i = 0; i < results.length; i++) {
-					results[i]=searcher.doc(sd[i].doc);
+          results[i] = searcher.doc(sd[i].doc);
-					request.setAttribute("results", results);
-				}
-			}
-			RequestDispatcher dispatcher = getServletContext().getRequestDispatcher("/index.jsp");
+          request.setAttribute("results", results);
+        }
+      }
+      RequestDispatcher dispatcher = getServletContext().getRequestDispatcher("/index.jsp");
-			dispatcher.forward(request,response);
+      dispatcher.forward(request, response);
-		}
+    }
-		catch(Exception e){
+    catch (Exception e) {
-			throw new ServletException("Error processing query",e);
+      throw new ServletException("Error processing query", e);
-		}
-	}
+    }
+  }
 
-	private void openExampleIndex() throws CorruptIndexException, IOException {
+  private void openExampleIndex() throws CorruptIndexException, IOException {
-
-		//Create a RAM-based index from our test data file
+    //Create a RAM-based index from our test data file
-		RAMDirectory rd=new RAMDirectory();
+    RAMDirectory rd = new RAMDirectory();
-                IndexWriterConfig iwConfig = new IndexWriterConfig(Version.LUCENE_40, analyzer);
+    IndexWriterConfig iwConfig = new IndexWriterConfig(Version.LUCENE_40, analyzer);
-		IndexWriter writer=new IndexWriter (rd, iwConfig);
+    IndexWriter writer = new IndexWriter(rd, iwConfig);
-		InputStream dataIn=getServletContext().getResourceAsStream("/WEB-INF/data.tsv");
+    InputStream dataIn = getServletContext().getResourceAsStream("/WEB-INF/data.tsv");
-		BufferedReader br = new BufferedReader(new InputStreamReader(dataIn));
-		String line = br.readLine();
+    BufferedReader br = new BufferedReader(new InputStreamReader(dataIn));
+    String line = br.readLine();
-		while(line!=null)
-		{
+    while (line != null) {
-			line=line.trim();
+      line = line.trim();
-			if(line.length()>0)
-			{
+      if (line.length() > 0) {
-				//parse row and create a document
+        //parse row and create a document
-				StringTokenizer st=new StringTokenizer(line,"\t");
+        StringTokenizer st = new StringTokenizer(line, "\t");
-				Document doc=new Document();
+        Document doc = new Document();
-				doc.add(new Field("location",st.nextToken(),Field.Store.YES,
+        doc.add(new Field("location", st.nextToken(), Field.Store.YES,
-						Field.Index.ANALYZED_NO_NORMS));
+            Field.Index.ANALYZED_NO_NORMS));
-				doc.add(new Field("salary",st.nextToken(),Field.Store.YES,
+        doc.add(new Field("salary", st.nextToken(), Field.Store.YES,
-						Field.Index.ANALYZED_NO_NORMS));
+            Field.Index.ANALYZED_NO_NORMS));
-				doc.add(new Field("type",st.nextToken(),Field.Store.YES,
+        doc.add(new Field("type", st.nextToken(), Field.Store.YES,
-						Field.Index.ANALYZED_NO_NORMS));
+            Field.Index.ANALYZED_NO_NORMS));
-				doc.add(new Field("description",st.nextToken(),Field.Store.YES,
+        doc.add(new Field("description", st.nextToken(), Field.Store.YES,
-						Field.Index.ANALYZED));
-				writer.addDocument(doc);
-			}
+            Field.Index.ANALYZED));
+        writer.addDocument(doc);
+      }
-			line=br.readLine();
+      line = br.readLine();
-		}
-		writer.close();
+    }
+    writer.close();
 
-		//open searcher
+    //open searcher
-		searcher=new IndexSearcher(rd, true);
+    searcher = new IndexSearcher(rd, true);
-	}
+  }
 }
Index: lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/BooleanQueryBuilder.java
===================================================================
--- lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/BooleanQueryBuilder.java	(revision 811070)
+++ lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/BooleanQueryBuilder.java	Thu Jul 14 16:59:05 NZST 2011
@@ -30,73 +30,61 @@
  */
 
 /**
- * 
+ *
  */
 public class BooleanQueryBuilder implements QueryBuilder {
-	
+
-	private QueryBuilder factory;
+  private final QueryBuilder factory;
 
-	public BooleanQueryBuilder(QueryBuilder factory)
-	{
+  public BooleanQueryBuilder(QueryBuilder factory) {
-		this.factory=factory;
+    this.factory = factory;
-	}
+  }
 
-	/* (non-Javadoc)
-	 * @see org.apache.lucene.xmlparser.QueryObjectBuilder#process(org.w3c.dom.Element)
-	 */
+  /* (non-Javadoc)
+    * @see org.apache.lucene.xmlparser.QueryObjectBuilder#process(org.w3c.dom.Element)
+    */
+
-	public Query getQuery(Element e) throws ParserException {
+  public Query getQuery(Element e) throws ParserException {
-		BooleanQuery bq=new BooleanQuery(DOMUtils.getAttribute(e,"disableCoord",false));
+    BooleanQuery bq = new BooleanQuery(DOMUtils.getAttribute(e, "disableCoord", false));
-		bq.setMinimumNumberShouldMatch(DOMUtils.getAttribute(e,"minimumNumberShouldMatch",0));
+    bq.setMinimumNumberShouldMatch(DOMUtils.getAttribute(e, "minimumNumberShouldMatch", 0));
-		bq.setBoost(DOMUtils.getAttribute(e,"boost",1.0f));
+    bq.setBoost(DOMUtils.getAttribute(e, "boost", 1.0f));
-		
-		NodeList nl = e.getChildNodes();
+
+    NodeList nl = e.getChildNodes();
-		for(int i=0;i<nl.getLength();i++)
-		{
+    for (int i = 0; i < nl.getLength(); i++) {
-			Node node = nl.item(i);
+      Node node = nl.item(i);
-			if(node.getNodeName().equals("Clause"))
-			{
+      if (node.getNodeName().equals("Clause")) {
-				Element clauseElem=(Element) node;
+        Element clauseElem = (Element) node;
-				BooleanClause.Occur occurs=getOccursValue(clauseElem);
+        BooleanClause.Occur occurs = getOccursValue(clauseElem);
-				
+
-	 			Element clauseQuery=DOMUtils.getFirstChildOrFail(clauseElem);
+        Element clauseQuery = DOMUtils.getFirstChildOrFail(clauseElem);
-	 			Query q=factory.getQuery(clauseQuery);
+        Query q = factory.getQuery(clauseQuery);
-	 			bq.add(new BooleanClause(q,occurs));
+        bq.add(new BooleanClause(q, occurs));
-			}
-		}
-		
-		return bq;
-	}
+      }
+    }
+
+    return bq;
+  }
-	static BooleanClause.Occur getOccursValue(Element clauseElem) throws ParserException
-	{
+
+  static BooleanClause.Occur getOccursValue(Element clauseElem) throws ParserException {
-		String occs=clauseElem.getAttribute("occurs");
+    String occs = clauseElem.getAttribute("occurs");
-		BooleanClause.Occur occurs=BooleanClause.Occur.SHOULD;
+    BooleanClause.Occur occurs = BooleanClause.Occur.SHOULD;
-		if("must".equalsIgnoreCase(occs))
-		{
+    if ("must".equalsIgnoreCase(occs)) {
-			occurs=BooleanClause.Occur.MUST;
+      occurs = BooleanClause.Occur.MUST;
-		}
-		else
-		{
-			if("mustNot".equalsIgnoreCase(occs))
-			{
+    } else {
+      if ("mustNot".equalsIgnoreCase(occs)) {
-				occurs=BooleanClause.Occur.MUST_NOT;
+        occurs = BooleanClause.Occur.MUST_NOT;
-			}			
-			else
-			{
-				if(("should".equalsIgnoreCase(occs))||("".equals(occs)))
-				{
+      } else {
+        if (("should".equalsIgnoreCase(occs)) || ("".equals(occs))) {
-					occurs=BooleanClause.Occur.SHOULD;
+          occurs = BooleanClause.Occur.SHOULD;
-				}			
-				else				
-				{
-					if(occs!=null)
-					{
+        } else {
+          if (occs != null) {
-						throw new ParserException("Invalid value for \"occurs\" attribute of clause:"+occs);
+            throw new ParserException("Invalid value for \"occurs\" attribute of clause:" + occs);
-					}
-				}
-			}
-		}
-		return occurs;
-		
-	}
+          }
+        }
+      }
+    }
+    return occurs;
+
+  }
 
 }
Index: lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/CoreParser.java
===================================================================
--- lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/CoreParser.java	(revision 1145016)
+++ lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/CoreParser.java	Thu Jul 14 16:58:10 NZST 2011
@@ -1,10 +1,5 @@
 package org.apache.lucene.xmlparser;
 
-import java.io.InputStream;
-
-import javax.xml.parsers.DocumentBuilder;
-import javax.xml.parsers.DocumentBuilderFactory;
-
 import org.apache.lucene.analysis.Analyzer;
 import org.apache.lucene.queryparser.classic.QueryParser;
 import org.apache.lucene.search.Query;
@@ -12,6 +7,10 @@
 import org.w3c.dom.Document;
 import org.w3c.dom.Element;
 
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import java.io.InputStream;
+
 /**
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -28,143 +27,130 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 /**
  * Assembles a QueryBuilder which uses only core Lucene Query objects
- *
  */
-public class CoreParser implements QueryBuilder
-{
+public class CoreParser implements QueryBuilder {
-	
-	protected Analyzer analyzer;
-	protected QueryParser parser;
-	protected QueryBuilderFactory queryFactory;
-	protected FilterBuilderFactory filterFactory;
-	//Controls the max size of the LRU cache used for QueryFilter objects parsed.
+
+  protected Analyzer analyzer;
+  protected QueryParser parser;
+  protected QueryBuilderFactory queryFactory;
+  protected FilterBuilderFactory filterFactory;
+  //Controls the max size of the LRU cache used for QueryFilter objects parsed.
-	public static int maxNumCachedFilters=20;
+  public static int maxNumCachedFilters = 20;
 
 
-	/**
-	 * Construct an XML parser that uses a single instance QueryParser for handling 
-	 * UserQuery tags - all parse operations are synchronised on this parser
+  /**
+   * Construct an XML parser that uses a single instance QueryParser for handling
+   * UserQuery tags - all parse operations are synchronised on this parser
+   *
-	 * @param analyzer
-	 * @param parser A QueryParser which will be synchronized on during parse calls.
-	 */
+   * @param analyzer
+   * @param parser A QueryParser which will be synchronized on during parse calls.
+   */
-	public CoreParser(Analyzer analyzer, QueryParser parser)
-	{
+  public CoreParser(Analyzer analyzer, QueryParser parser) {
-		this(null,analyzer,parser);
+    this(null, analyzer, parser);
-	}
-	
-	/**
-	 * Constructs an XML parser that creates a QueryParser for each UserQuery request.
+  }
+
+  /**
+   * Constructs an XML parser that creates a QueryParser for each UserQuery request.
+   *
-	 * @param defaultField The default field name used by QueryParsers constructed for UserQuery tags 
-	 * @param analyzer 
-	 */
+   * @param defaultField The default field name used by QueryParsers constructed for UserQuery tags
+   * @param analyzer
+   */
-	public CoreParser(String defaultField, Analyzer analyzer)
-	{
+  public CoreParser(String defaultField, Analyzer analyzer) {
-		this(defaultField,analyzer,null);
+    this(defaultField, analyzer, null);
-	}	
-	
+  }
+
-	protected CoreParser(String defaultField,Analyzer analyzer, QueryParser parser)
-	{
+  protected CoreParser(String defaultField, Analyzer analyzer, QueryParser parser) {
-		this.analyzer=analyzer;
+    this.analyzer = analyzer;
-		this.parser=parser;
+    this.parser = parser;
-		filterFactory = new FilterBuilderFactory();
+    filterFactory = new FilterBuilderFactory();
-		filterFactory.addBuilder("RangeFilter",new RangeFilterBuilder());
+    filterFactory.addBuilder("RangeFilter", new RangeFilterBuilder());
-		filterFactory.addBuilder("NumericRangeFilter",new NumericRangeFilterBuilder());
+    filterFactory.addBuilder("NumericRangeFilter", new NumericRangeFilterBuilder());
-		
-		queryFactory = new QueryBuilderFactory();
+
+    queryFactory = new QueryBuilderFactory();
-		queryFactory.addBuilder("TermQuery",new TermQueryBuilder());
+    queryFactory.addBuilder("TermQuery", new TermQueryBuilder());
-		queryFactory.addBuilder("TermsQuery",new TermsQueryBuilder(analyzer));
+    queryFactory.addBuilder("TermsQuery", new TermsQueryBuilder(analyzer));
-		queryFactory.addBuilder("MatchAllDocsQuery",new MatchAllDocsQueryBuilder());
+    queryFactory.addBuilder("MatchAllDocsQuery", new MatchAllDocsQueryBuilder());
-		queryFactory.addBuilder("BooleanQuery",new BooleanQueryBuilder(queryFactory));
+    queryFactory.addBuilder("BooleanQuery", new BooleanQueryBuilder(queryFactory));
-		queryFactory.addBuilder("NumericRangeQuery",new NumericRangeQueryBuilder());
+    queryFactory.addBuilder("NumericRangeQuery", new NumericRangeQueryBuilder());
-		if(parser!=null)
-		{
+    if (parser != null) {
-			queryFactory.addBuilder("UserQuery",new UserInputQueryBuilder(parser));
+      queryFactory.addBuilder("UserQuery", new UserInputQueryBuilder(parser));
-		}
-		else
-		{
+    } else {
-			queryFactory.addBuilder("UserQuery",new UserInputQueryBuilder(defaultField,analyzer));			
+      queryFactory.addBuilder("UserQuery", new UserInputQueryBuilder(defaultField, analyzer));
-		}
+    }
-		queryFactory.addBuilder("FilteredQuery",new FilteredQueryBuilder(filterFactory,queryFactory));
+    queryFactory.addBuilder("FilteredQuery", new FilteredQueryBuilder(filterFactory, queryFactory));
-		queryFactory.addBuilder("ConstantScoreQuery",new ConstantScoreQueryBuilder(filterFactory));
+    queryFactory.addBuilder("ConstantScoreQuery", new ConstantScoreQueryBuilder(filterFactory));
-		
+
-		filterFactory.addBuilder("CachedFilter",new CachedFilterBuilder(queryFactory,
+    filterFactory.addBuilder("CachedFilter", new CachedFilterBuilder(queryFactory,
-							filterFactory, maxNumCachedFilters));
-		
-		
+        filterFactory, maxNumCachedFilters));
+
+
-		SpanQueryBuilderFactory sqof=new SpanQueryBuilderFactory();
+    SpanQueryBuilderFactory sqof = new SpanQueryBuilderFactory();
 
-		SpanNearBuilder snb=new SpanNearBuilder(sqof);
+    SpanNearBuilder snb = new SpanNearBuilder(sqof);
-		sqof.addBuilder("SpanNear",snb);
+    sqof.addBuilder("SpanNear", snb);
-		queryFactory.addBuilder("SpanNear",snb);
+    queryFactory.addBuilder("SpanNear", snb);
 
-    BoostingTermBuilder btb=new BoostingTermBuilder();
+    BoostingTermBuilder btb = new BoostingTermBuilder();
-    sqof.addBuilder("BoostingTermQuery",btb);
+    sqof.addBuilder("BoostingTermQuery", btb);
-    queryFactory.addBuilder("BoostingTermQuery",btb);        
+    queryFactory.addBuilder("BoostingTermQuery", btb);
 
-    SpanTermBuilder snt=new SpanTermBuilder();
+    SpanTermBuilder snt = new SpanTermBuilder();
-		sqof.addBuilder("SpanTerm",snt);
+    sqof.addBuilder("SpanTerm", snt);
-		queryFactory.addBuilder("SpanTerm",snt);
+    queryFactory.addBuilder("SpanTerm", snt);
-		
+
-		SpanOrBuilder sot=new SpanOrBuilder(sqof);
+    SpanOrBuilder sot = new SpanOrBuilder(sqof);
-		sqof.addBuilder("SpanOr",sot);
+    sqof.addBuilder("SpanOr", sot);
-		queryFactory.addBuilder("SpanOr",sot);
+    queryFactory.addBuilder("SpanOr", sot);
 
-		SpanOrTermsBuilder sots=new SpanOrTermsBuilder(analyzer);
+    SpanOrTermsBuilder sots = new SpanOrTermsBuilder(analyzer);
-		sqof.addBuilder("SpanOrTerms",sots);
+    sqof.addBuilder("SpanOrTerms", sots);
-		queryFactory.addBuilder("SpanOrTerms",sots);		
+    queryFactory.addBuilder("SpanOrTerms", sots);
-		
+
-		SpanFirstBuilder sft=new SpanFirstBuilder(sqof);
+    SpanFirstBuilder sft = new SpanFirstBuilder(sqof);
-		sqof.addBuilder("SpanFirst",sft);
+    sqof.addBuilder("SpanFirst", sft);
-		queryFactory.addBuilder("SpanFirst",sft);
+    queryFactory.addBuilder("SpanFirst", sft);
-		
+
-		SpanNotBuilder snot=new SpanNotBuilder(sqof);
+    SpanNotBuilder snot = new SpanNotBuilder(sqof);
-		sqof.addBuilder("SpanNot",snot);
+    sqof.addBuilder("SpanNot", snot);
-		queryFactory.addBuilder("SpanNot",snot);	
+    queryFactory.addBuilder("SpanNot", snot);
-	}
-	
+  }
+
-	public Query parse(InputStream xmlStream) throws ParserException
-	{
+  public Query parse(InputStream xmlStream) throws ParserException {
-		return getQuery(parseXML(xmlStream).getDocumentElement());
-	}
-	
+    return getQuery(parseXML(xmlStream).getDocumentElement());
+  }
+
-	public void addQueryBuilder(String nodeName,QueryBuilder builder)
-	{
+  public void addQueryBuilder(String nodeName, QueryBuilder builder) {
-		queryFactory.addBuilder(nodeName,builder);
+    queryFactory.addBuilder(nodeName, builder);
-	}
+  }
-	public void addFilterBuilder(String nodeName,FilterBuilder builder)
-	{
+
+  public void addFilterBuilder(String nodeName, FilterBuilder builder) {
-		filterFactory.addBuilder(nodeName,builder);
+    filterFactory.addBuilder(nodeName, builder);
-	}
-	
+  }
+
-	private static Document parseXML(InputStream pXmlFile) throws ParserException
-	{
+  private static Document parseXML(InputStream pXmlFile) throws ParserException {
-		DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
-		DocumentBuilder db = null;
+    DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
+    DocumentBuilder db = null;
-		try
-		{
+    try {
-			db = dbf.newDocumentBuilder();
-		}
+      db = dbf.newDocumentBuilder();
+    }
-		catch (Exception se)
-		{
+    catch (Exception se) {
-			throw new ParserException("XML Parser configuration error", se);
-		}
-		org.w3c.dom.Document doc = null;
+      throw new ParserException("XML Parser configuration error", se);
+    }
+    org.w3c.dom.Document doc = null;
-		try
-		{
+    try {
-			doc = db.parse(pXmlFile);
-		}
+      doc = db.parse(pXmlFile);
+    }
-		catch (Exception se)
-		{
+    catch (Exception se) {
-			throw new ParserException("Error parsing XML stream:" + se, se);
-		}
-		return doc;
-	}
-	
+      throw new ParserException("Error parsing XML stream:" + se, se);
+    }
+    return doc;
+  }
+
 
-	public Query getQuery(Element e) throws ParserException
-	{
+  public Query getQuery(Element e) throws ParserException {
-		return queryFactory.getQuery(e);
+    return queryFactory.getQuery(e);
 	}
 }
Index: lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/SpanNearBuilder.java
===================================================================
--- lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/SpanNearBuilder.java	(revision 834414)
+++ lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/SpanNearBuilder.java	Thu Jul 14 17:15:25 NZST 2011
@@ -1,13 +1,14 @@
 package org.apache.lucene.xmlparser.builders;
 
-import java.util.ArrayList;
-
 import org.apache.lucene.search.spans.SpanNearQuery;
 import org.apache.lucene.search.spans.SpanQuery;
 import org.apache.lucene.xmlparser.DOMUtils;
 import org.apache.lucene.xmlparser.ParserException;
 import org.w3c.dom.Element;
 import org.w3c.dom.Node;
+
+import java.util.ArrayList;
+import java.util.List;
 /**
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -26,32 +27,28 @@
  */
 
 /**
- * 
+ *
  */
-public class SpanNearBuilder extends SpanBuilderBase
-{
-	SpanQueryBuilder factory;
-	public SpanNearBuilder(SpanQueryBuilder factory)
-	{
+public class SpanNearBuilder extends SpanBuilderBase {
+
+  private final SpanQueryBuilder factory;
+
+  public SpanNearBuilder(SpanQueryBuilder factory) {
-		this.factory=factory;
+    this.factory = factory;
-	}
-	
+  }
+
-	public SpanQuery getSpanQuery(Element e) throws ParserException
-	{
+  public SpanQuery getSpanQuery(Element e) throws ParserException {
- 		String slopString=DOMUtils.getAttributeOrFail(e,"slop");
+    String slopString = DOMUtils.getAttributeOrFail(e, "slop");
-  		int slop=Integer.parseInt(slopString);
+    int slop = Integer.parseInt(slopString);
-		boolean inOrder=DOMUtils.getAttribute(e,"inOrder",false);
+    boolean inOrder = DOMUtils.getAttribute(e, "inOrder", false);
-		ArrayList<SpanQuery> spans=new ArrayList<SpanQuery>();
-		for (Node kid = e.getFirstChild(); kid != null; kid = kid.getNextSibling())
-		{
-				if (kid.getNodeType() == Node.ELEMENT_NODE) 
-				{
+    List<SpanQuery> spans = new ArrayList<SpanQuery>();
+    for (Node kid = e.getFirstChild(); kid != null; kid = kid.getNextSibling()) {
+      if (kid.getNodeType() == Node.ELEMENT_NODE) {
-					spans.add(factory.getSpanQuery((Element) kid));
-				}
-		}
+        spans.add(factory.getSpanQuery((Element) kid));
+      }
+    }
-		SpanQuery[] spanQueries= spans.toArray(new SpanQuery[spans.size()]);
+    SpanQuery[] spanQueries = spans.toArray(new SpanQuery[spans.size()]);
-		SpanNearQuery snq=new SpanNearQuery(spanQueries,slop,inOrder);
-		return snq;
+    return new SpanNearQuery(spanQueries, slop, inOrder);
-	}
+  }
 
 }
Index: lucene/contrib/xml-query-parser/src/test/org/apache/lucene/xmlparser/builders/TestNumericRangeFilterBuilder.java
===================================================================
--- lucene/contrib/xml-query-parser/src/test/org/apache/lucene/xmlparser/builders/TestNumericRangeFilterBuilder.java	(revision 1144658)
+++ lucene/contrib/xml-query-parser/src/test/org/apache/lucene/xmlparser/builders/TestNumericRangeFilterBuilder.java	Thu Jul 14 17:19:09 NZST 2011
@@ -17,16 +17,6 @@
  * limitations under the License.
  */
 
-import java.io.ByteArrayInputStream;
-import java.io.IOException;
-import java.io.InputStream;
-
-import javax.xml.parsers.DocumentBuilder;
-import javax.xml.parsers.DocumentBuilderFactory;
-import javax.xml.parsers.ParserConfigurationException;
-
-import org.apache.lucene.util.LuceneTestCase;
-
 import org.apache.lucene.index.IndexReader;
 import org.apache.lucene.index.IndexReader.AtomicReaderContext;
 import org.apache.lucene.index.IndexWriter;
@@ -34,184 +24,191 @@
 import org.apache.lucene.search.Filter;
 import org.apache.lucene.search.NumericRangeFilter;
 import org.apache.lucene.store.Directory;
+import org.apache.lucene.util.LuceneTestCase;
 import org.apache.lucene.xmlparser.ParserException;
 import org.w3c.dom.Document;
 import org.xml.sax.SAXException;
 
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
 public class TestNumericRangeFilterBuilder extends LuceneTestCase {
 
-	public void testGetFilterHandleNumericParseErrorStrict() throws Exception {
-		NumericRangeFilterBuilder filterBuilder = new NumericRangeFilterBuilder();
-		filterBuilder.setStrictMode(true);
+  public void testGetFilterHandleNumericParseErrorStrict() throws Exception {
+    NumericRangeFilterBuilder filterBuilder = new NumericRangeFilterBuilder();
+    filterBuilder.setStrictMode(true);
 
-		String xml = "<NumericRangeFilter fieldName='AGE' type='int' lowerTerm='-1' upperTerm='NaN'/>";
-		Document doc = getDocumentFromString(xml);
-		try {
-			filterBuilder.getFilter(doc.getDocumentElement());
-		} catch (ParserException e) {
-			return;
-		}
-		fail("Expected to throw " + ParserException.class);
-	}
+    String xml = "<NumericRangeFilter fieldName='AGE' type='int' lowerTerm='-1' upperTerm='NaN'/>";
+    Document doc = getDocumentFromString(xml);
+    try {
+      filterBuilder.getFilter(doc.getDocumentElement());
+    } catch (ParserException e) {
+      return;
+    }
+    fail("Expected to throw " + ParserException.class);
+  }
 
-	public void testGetFilterHandleNumericParseError() throws Exception {
-		NumericRangeFilterBuilder filterBuilder = new NumericRangeFilterBuilder();
-		filterBuilder.setStrictMode(false);
+  public void testGetFilterHandleNumericParseError() throws Exception {
+    NumericRangeFilterBuilder filterBuilder = new NumericRangeFilterBuilder();
+    filterBuilder.setStrictMode(false);
 
-		String xml = "<NumericRangeFilter fieldName='AGE' type='int' lowerTerm='-1' upperTerm='NaN'/>";
-		Document doc = getDocumentFromString(xml);
-		Filter filter = filterBuilder.getFilter(doc.getDocumentElement());
-		Directory ramDir = newDirectory();
-		IndexWriter writer = new IndexWriter(ramDir, newIndexWriterConfig(TEST_VERSION_CURRENT, null));
-		writer.commit();
+    String xml = "<NumericRangeFilter fieldName='AGE' type='int' lowerTerm='-1' upperTerm='NaN'/>";
+    Document doc = getDocumentFromString(xml);
+    Filter filter = filterBuilder.getFilter(doc.getDocumentElement());
+    Directory ramDir = newDirectory();
+    IndexWriter writer = new IndexWriter(ramDir, newIndexWriterConfig(TEST_VERSION_CURRENT, null));
+    writer.commit();
-		try
-		{
+    try {
-			IndexReader reader = new SlowMultiReaderWrapper(IndexReader.open(ramDir, true));
+      IndexReader reader = new SlowMultiReaderWrapper(IndexReader.open(ramDir, true));
-			try
-			{
+      try {
-				assertNull(filter.getDocIdSet((AtomicReaderContext) reader.getTopReaderContext()));
-			}
+        assertNull(filter.getDocIdSet((AtomicReaderContext) reader.getTopReaderContext()));
+      }
-			finally
-			{
+      finally {
-				reader.close();
-			}
-		}
+        reader.close();
+      }
+    }
-		finally
-		{
+    finally {
-			writer.commit();
-			writer.close();
-			ramDir.close();
-		}
-	}
+      writer.commit();
+      writer.close();
+      ramDir.close();
+    }
+  }
 
+  @SuppressWarnings("unchecked")
-	public void testGetFilterInt() throws Exception {
-		NumericRangeFilterBuilder filterBuilder = new NumericRangeFilterBuilder();
-		filterBuilder.setStrictMode(true);
+  public void testGetFilterInt() throws Exception {
+    NumericRangeFilterBuilder filterBuilder = new NumericRangeFilterBuilder();
+    filterBuilder.setStrictMode(true);
 
-		String xml = "<NumericRangeFilter fieldName='AGE' type='int' lowerTerm='-1' upperTerm='10'/>";
-		Document doc = getDocumentFromString(xml);
-		Filter filter = filterBuilder.getFilter(doc.getDocumentElement());
-		assertTrue(filter instanceof NumericRangeFilter<?>);
+    String xml = "<NumericRangeFilter fieldName='AGE' type='int' lowerTerm='-1' upperTerm='10'/>";
+    Document doc = getDocumentFromString(xml);
+    Filter filter = filterBuilder.getFilter(doc.getDocumentElement());
+    assertTrue(filter instanceof NumericRangeFilter<?>);
-		@SuppressWarnings("unchecked")
+
-		NumericRangeFilter<Integer> numRangeFilter = (NumericRangeFilter<Integer>) filter;
-		assertEquals(Integer.valueOf(-1), numRangeFilter.getMin());
-		assertEquals(Integer.valueOf(10), numRangeFilter.getMax());
-		assertEquals("AGE", numRangeFilter.getField());
-		assertTrue(numRangeFilter.includesMin());
-		assertTrue(numRangeFilter.includesMax());
+    NumericRangeFilter<Integer> numRangeFilter = (NumericRangeFilter<Integer>) filter;
+    assertEquals(Integer.valueOf(-1), numRangeFilter.getMin());
+    assertEquals(Integer.valueOf(10), numRangeFilter.getMax());
+    assertEquals("AGE", numRangeFilter.getField());
+    assertTrue(numRangeFilter.includesMin());
+    assertTrue(numRangeFilter.includesMax());
 
-		String xml2 = "<NumericRangeFilter fieldName='AGE' type='int' lowerTerm='-1' upperTerm='10' includeUpper='false'/>";
-		Document doc2 = getDocumentFromString(xml2);
-		Filter filter2 = filterBuilder.getFilter(doc2.getDocumentElement());
-		assertTrue(filter2 instanceof NumericRangeFilter<?>);
+    String xml2 = "<NumericRangeFilter fieldName='AGE' type='int' lowerTerm='-1' upperTerm='10' includeUpper='false'/>";
+    Document doc2 = getDocumentFromString(xml2);
+    Filter filter2 = filterBuilder.getFilter(doc2.getDocumentElement());
+    assertTrue(filter2 instanceof NumericRangeFilter<?>);
-		@SuppressWarnings("unchecked")
+
-		NumericRangeFilter<Integer> numRangeFilter2 = (NumericRangeFilter) filter2;
-		assertEquals(Integer.valueOf(-1), numRangeFilter2.getMin());
-		assertEquals(Integer.valueOf(10), numRangeFilter2.getMax());
-		assertEquals("AGE", numRangeFilter2.getField());
-		assertTrue(numRangeFilter2.includesMin());
-		assertFalse(numRangeFilter2.includesMax());
-	}
+    NumericRangeFilter<Integer> numRangeFilter2 = (NumericRangeFilter) filter2;
+    assertEquals(Integer.valueOf(-1), numRangeFilter2.getMin());
+    assertEquals(Integer.valueOf(10), numRangeFilter2.getMax());
+    assertEquals("AGE", numRangeFilter2.getField());
+    assertTrue(numRangeFilter2.includesMin());
+    assertFalse(numRangeFilter2.includesMax());
+  }
 
+  @SuppressWarnings("unchecked")
-	public void testGetFilterLong() throws Exception {
-		NumericRangeFilterBuilder filterBuilder = new NumericRangeFilterBuilder();
-		filterBuilder.setStrictMode(true);
+  public void testGetFilterLong() throws Exception {
+    NumericRangeFilterBuilder filterBuilder = new NumericRangeFilterBuilder();
+    filterBuilder.setStrictMode(true);
 
-		String xml = "<NumericRangeFilter fieldName='AGE' type='LoNg' lowerTerm='-2321' upperTerm='60000000'/>";
-		Document doc = getDocumentFromString(xml);
-		Filter filter = filterBuilder.getFilter(doc.getDocumentElement());
-		assertTrue(filter instanceof NumericRangeFilter<?>);
+    String xml = "<NumericRangeFilter fieldName='AGE' type='LoNg' lowerTerm='-2321' upperTerm='60000000'/>";
+    Document doc = getDocumentFromString(xml);
+    Filter filter = filterBuilder.getFilter(doc.getDocumentElement());
+    assertTrue(filter instanceof NumericRangeFilter<?>);
-		@SuppressWarnings("unchecked")
+
-		NumericRangeFilter<Long> numRangeFilter = (NumericRangeFilter) filter;
-		assertEquals(Long.valueOf(-2321L), numRangeFilter.getMin());
-		assertEquals(Long.valueOf(60000000L), numRangeFilter.getMax());
-		assertEquals("AGE", numRangeFilter.getField());
-		assertTrue(numRangeFilter.includesMin());
-		assertTrue(numRangeFilter.includesMax());
+    NumericRangeFilter<Long> numRangeFilter = (NumericRangeFilter) filter;
+    assertEquals(Long.valueOf(-2321L), numRangeFilter.getMin());
+    assertEquals(Long.valueOf(60000000L), numRangeFilter.getMax());
+    assertEquals("AGE", numRangeFilter.getField());
+    assertTrue(numRangeFilter.includesMin());
+    assertTrue(numRangeFilter.includesMax());
 
-		String xml2 = "<NumericRangeFilter fieldName='AGE' type='LoNg' lowerTerm='-2321' upperTerm='60000000' includeUpper='false'/>";
-		Document doc2 = getDocumentFromString(xml2);
-		Filter filter2 = filterBuilder.getFilter(doc2.getDocumentElement());
-		assertTrue(filter2 instanceof NumericRangeFilter<?>);
+    String xml2 = "<NumericRangeFilter fieldName='AGE' type='LoNg' lowerTerm='-2321' upperTerm='60000000' includeUpper='false'/>";
+    Document doc2 = getDocumentFromString(xml2);
+    Filter filter2 = filterBuilder.getFilter(doc2.getDocumentElement());
+    assertTrue(filter2 instanceof NumericRangeFilter<?>);
-		@SuppressWarnings("unchecked")
-		NumericRangeFilter<Long> numRangeFilter2 = (NumericRangeFilter) filter2;
-		assertEquals(Long.valueOf(-2321L), numRangeFilter2.getMin());
-		assertEquals(Long.valueOf(60000000L), numRangeFilter2.getMax());
-		assertEquals("AGE", numRangeFilter2.getField());
-		assertTrue(numRangeFilter2.includesMin());
-		assertFalse(numRangeFilter2.includesMax());
-	}
+    NumericRangeFilter<Long> numRangeFilter2 = (NumericRangeFilter) filter2;
+    assertEquals(Long.valueOf(-2321L), numRangeFilter2.getMin());
+    assertEquals(Long.valueOf(60000000L), numRangeFilter2.getMax());
+    assertEquals("AGE", numRangeFilter2.getField());
+    assertTrue(numRangeFilter2.includesMin());
+    assertFalse(numRangeFilter2.includesMax());
+  }
 
+  @SuppressWarnings("unchecked")
-	public void testGetFilterDouble() throws Exception {
-		NumericRangeFilterBuilder filterBuilder = new NumericRangeFilterBuilder();
-		filterBuilder.setStrictMode(true);
+  public void testGetFilterDouble() throws Exception {
+    NumericRangeFilterBuilder filterBuilder = new NumericRangeFilterBuilder();
+    filterBuilder.setStrictMode(true);
 
-		String xml = "<NumericRangeFilter fieldName='AGE' type='doubLe' lowerTerm='-23.21' upperTerm='60000.00023'/>";
-		Document doc = getDocumentFromString(xml);
+    String xml = "<NumericRangeFilter fieldName='AGE' type='doubLe' lowerTerm='-23.21' upperTerm='60000.00023'/>";
+    Document doc = getDocumentFromString(xml);
 
-		Filter filter = filterBuilder.getFilter(doc.getDocumentElement());
-		assertTrue(filter instanceof NumericRangeFilter<?>);
+    Filter filter = filterBuilder.getFilter(doc.getDocumentElement());
+    assertTrue(filter instanceof NumericRangeFilter<?>);
-		@SuppressWarnings("unchecked")
+
-		NumericRangeFilter<Double> numRangeFilter = (NumericRangeFilter) filter;
-		assertEquals(Double.valueOf(-23.21d), numRangeFilter.getMin());
-		assertEquals(Double.valueOf(60000.00023d), numRangeFilter.getMax());
-		assertEquals("AGE", numRangeFilter.getField());
-		assertTrue(numRangeFilter.includesMin());
-		assertTrue(numRangeFilter.includesMax());
+    NumericRangeFilter<Double> numRangeFilter = (NumericRangeFilter) filter;
+    assertEquals(Double.valueOf(-23.21d), numRangeFilter.getMin());
+    assertEquals(Double.valueOf(60000.00023d), numRangeFilter.getMax());
+    assertEquals("AGE", numRangeFilter.getField());
+    assertTrue(numRangeFilter.includesMin());
+    assertTrue(numRangeFilter.includesMax());
 
-		String xml2 = "<NumericRangeFilter fieldName='AGE' type='doubLe' lowerTerm='-23.21' upperTerm='60000.00023' includeUpper='false'/>";
-		Document doc2 = getDocumentFromString(xml2);
-		Filter filter2 = filterBuilder.getFilter(doc2.getDocumentElement());
-		assertTrue(filter2 instanceof NumericRangeFilter<?>);
+    String xml2 = "<NumericRangeFilter fieldName='AGE' type='doubLe' lowerTerm='-23.21' upperTerm='60000.00023' includeUpper='false'/>";
+    Document doc2 = getDocumentFromString(xml2);
+    Filter filter2 = filterBuilder.getFilter(doc2.getDocumentElement());
+    assertTrue(filter2 instanceof NumericRangeFilter<?>);
-		@SuppressWarnings("unchecked")
+
-		NumericRangeFilter<Double> numRangeFilter2 = (NumericRangeFilter) filter2;
-		assertEquals(Double.valueOf(-23.21d), numRangeFilter2.getMin());
-		assertEquals(Double.valueOf(60000.00023d), numRangeFilter2.getMax());
-		assertEquals("AGE", numRangeFilter2.getField());
-		assertTrue(numRangeFilter2.includesMin());
-		assertFalse(numRangeFilter2.includesMax());
-	}
+    NumericRangeFilter<Double> numRangeFilter2 = (NumericRangeFilter) filter2;
+    assertEquals(Double.valueOf(-23.21d), numRangeFilter2.getMin());
+    assertEquals(Double.valueOf(60000.00023d), numRangeFilter2.getMax());
+    assertEquals("AGE", numRangeFilter2.getField());
+    assertTrue(numRangeFilter2.includesMin());
+    assertFalse(numRangeFilter2.includesMax());
+  }
 
+  @SuppressWarnings("unchecked")
-	public void testGetFilterFloat() throws Exception {
-		NumericRangeFilterBuilder filterBuilder = new NumericRangeFilterBuilder();
-		filterBuilder.setStrictMode(true);
+  public void testGetFilterFloat() throws Exception {
+    NumericRangeFilterBuilder filterBuilder = new NumericRangeFilterBuilder();
+    filterBuilder.setStrictMode(true);
 
-		String xml = "<NumericRangeFilter fieldName='AGE' type='FLOAT' lowerTerm='-2.321432' upperTerm='32432.23'/>";
-		Document doc = getDocumentFromString(xml);
+    String xml = "<NumericRangeFilter fieldName='AGE' type='FLOAT' lowerTerm='-2.321432' upperTerm='32432.23'/>";
+    Document doc = getDocumentFromString(xml);
 
-		Filter filter = filterBuilder.getFilter(doc.getDocumentElement());
-		assertTrue(filter instanceof NumericRangeFilter<?>);
+    Filter filter = filterBuilder.getFilter(doc.getDocumentElement());
+    assertTrue(filter instanceof NumericRangeFilter<?>);
-		@SuppressWarnings("unchecked")
+
-		NumericRangeFilter<Float> numRangeFilter = (NumericRangeFilter) filter;
-		assertEquals(Float.valueOf(-2.321432f), numRangeFilter.getMin());
-		assertEquals(Float.valueOf(32432.23f), numRangeFilter.getMax());
-		assertEquals("AGE", numRangeFilter.getField());
-		assertTrue(numRangeFilter.includesMin());
-		assertTrue(numRangeFilter.includesMax());
+    NumericRangeFilter<Float> numRangeFilter = (NumericRangeFilter) filter;
+    assertEquals(Float.valueOf(-2.321432f), numRangeFilter.getMin());
+    assertEquals(Float.valueOf(32432.23f), numRangeFilter.getMax());
+    assertEquals("AGE", numRangeFilter.getField());
+    assertTrue(numRangeFilter.includesMin());
+    assertTrue(numRangeFilter.includesMax());
 
-		String xml2 = "<NumericRangeFilter fieldName='AGE' type='FLOAT' lowerTerm='-2.321432' upperTerm='32432.23' includeUpper='false' precisionStep='2' />";
-		Document doc2 = getDocumentFromString(xml2);
+    String xml2 = "<NumericRangeFilter fieldName='AGE' type='FLOAT' lowerTerm='-2.321432' upperTerm='32432.23' includeUpper='false' precisionStep='2' />";
+    Document doc2 = getDocumentFromString(xml2);
 
-		Filter filter2 = filterBuilder.getFilter(doc2.getDocumentElement());
-		assertTrue(filter2 instanceof NumericRangeFilter<?>);
+    Filter filter2 = filterBuilder.getFilter(doc2.getDocumentElement());
+    assertTrue(filter2 instanceof NumericRangeFilter<?>);
-		@SuppressWarnings("unchecked")
+    
-		NumericRangeFilter<Float> numRangeFilter2 = (NumericRangeFilter) filter2;
-		assertEquals(Float.valueOf(-2.321432f), numRangeFilter2.getMin());
-		assertEquals(Float.valueOf(32432.23f), numRangeFilter2.getMax());
-		assertEquals("AGE", numRangeFilter2.getField());
-		assertTrue(numRangeFilter2.includesMin());
-		assertFalse(numRangeFilter2.includesMax());
-	}
+    NumericRangeFilter<Float> numRangeFilter2 = (NumericRangeFilter) filter2;
+    assertEquals(Float.valueOf(-2.321432f), numRangeFilter2.getMin());
+    assertEquals(Float.valueOf(32432.23f), numRangeFilter2.getMax());
+    assertEquals("AGE", numRangeFilter2.getField());
+    assertTrue(numRangeFilter2.includesMin());
+    assertFalse(numRangeFilter2.includesMax());
+  }
 
-	private static Document getDocumentFromString(String str)
-			throws SAXException, IOException, ParserConfigurationException {
-		InputStream is = new ByteArrayInputStream(str.getBytes());
-		DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
-		factory.setNamespaceAware(true);
-		DocumentBuilder builder = factory.newDocumentBuilder();
-		Document doc = builder.parse(is);
-		is.close();
-		return doc;
-	}
+  private static Document getDocumentFromString(String str)
+      throws SAXException, IOException, ParserConfigurationException {
+    InputStream is = new ByteArrayInputStream(str.getBytes());
+    DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
+    factory.setNamespaceAware(true);
+    DocumentBuilder builder = factory.newDocumentBuilder();
+    Document doc = builder.parse(is);
+    is.close();
+    return doc;
+  }
 
 }
Index: lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/FilterBuilderFactory.java
===================================================================
--- lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/FilterBuilderFactory.java	(revision 834414)
+++ lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/FilterBuilderFactory.java	Thu Jul 14 16:58:10 NZST 2011
@@ -3,10 +3,10 @@
  */
 package org.apache.lucene.xmlparser;
 
-import java.util.HashMap;
-
 import org.apache.lucene.search.Filter;
 import org.w3c.dom.Element;
+
+import java.util.HashMap;
 /**
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -25,26 +25,25 @@
  */
 
 /**
- * 
+ *
  */
 public class FilterBuilderFactory implements FilterBuilder {
 
-	HashMap<String,FilterBuilder> builders=new HashMap<String,FilterBuilder>();
+  HashMap<String, FilterBuilder> builders = new HashMap<String, FilterBuilder>();
-	
-	public Filter getFilter(Element n) throws ParserException {
+
+  public Filter getFilter(Element n) throws ParserException {
-		FilterBuilder builder= builders.get(n.getNodeName());
+    FilterBuilder builder = builders.get(n.getNodeName());
-		if(builder==null)
-		{
+    if (builder == null) {
-			throw new ParserException("No FilterBuilder defined for node "+n.getNodeName()); 
+      throw new ParserException("No FilterBuilder defined for node " + n.getNodeName());
-		}
-		return builder.getFilter(n); 
-	}
+    }
+    return builder.getFilter(n);
+  }
-	public void addBuilder(String nodeName,FilterBuilder builder)
-	{
+
+  public void addBuilder(String nodeName, FilterBuilder builder) {
-		builders.put(nodeName,builder);
+    builders.put(nodeName, builder);
-	}
+  }
-	public FilterBuilder getFilterBuilder(String nodeName)
-	{
+
+  public FilterBuilder getFilterBuilder(String nodeName) {
-		return builders.get(nodeName);		
-	}	
+    return builders.get(nodeName);
+  }
 }
Index: lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/BoostingTermBuilder.java
===================================================================
--- lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/BoostingTermBuilder.java	(revision 917019)
+++ lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/BoostingTermBuilder.java	Thu Jul 14 17:00:47 NZST 2011
@@ -1,9 +1,9 @@
 package org.apache.lucene.xmlparser.builders;
 
 import org.apache.lucene.index.Term;
-import org.apache.lucene.search.spans.SpanQuery;
-import org.apache.lucene.search.payloads.PayloadTermQuery;
 import org.apache.lucene.search.payloads.AveragePayloadFunction;
+import org.apache.lucene.search.payloads.PayloadTermQuery;
+import org.apache.lucene.search.spans.SpanQuery;
 import org.apache.lucene.xmlparser.DOMUtils;
 import org.apache.lucene.xmlparser.ParserException;
 import org.w3c.dom.Element;
@@ -26,20 +26,17 @@
  */
 
 /**
- * 
+ *
  */
-public class BoostingTermBuilder extends SpanBuilderBase
-{
+public class BoostingTermBuilder extends SpanBuilderBase {
 
-	public SpanQuery getSpanQuery(Element e) throws ParserException
-	{
+  public SpanQuery getSpanQuery(Element e) throws ParserException {
- 		String fieldName=DOMUtils.getAttributeWithInheritanceOrFail(e,"fieldName");
+    String fieldName = DOMUtils.getAttributeWithInheritanceOrFail(e, "fieldName");
- 		String value=DOMUtils.getNonBlankTextOrFail(e);
+    String value = DOMUtils.getNonBlankTextOrFail(e);
-  		PayloadTermQuery btq = new PayloadTermQuery(new Term(fieldName,value), new AveragePayloadFunction());
 
+    PayloadTermQuery btq = new PayloadTermQuery(new Term(fieldName, value), new AveragePayloadFunction());
-  		btq.setBoost(DOMUtils.getAttribute(e,"boost",1.0f));
+    btq.setBoost(DOMUtils.getAttribute(e, "boost", 1.0f));
-		return btq;
+    return btq;
-
-	}
+  }
 
 }
\ No newline at end of file
Index: lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/NumericRangeFilterBuilder.java
===================================================================
--- lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/NumericRangeFilterBuilder.java	(revision 1068526)
+++ lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/NumericRangeFilterBuilder.java	Thu Jul 14 17:15:25 NZST 2011
@@ -17,8 +17,6 @@
  * limitations under the License.
  */
 
-import java.io.IOException;
-
 import org.apache.lucene.index.IndexReader.AtomicReaderContext;
 import org.apache.lucene.search.DocIdSet;
 import org.apache.lucene.search.Filter;
@@ -29,6 +27,8 @@
 import org.apache.lucene.xmlparser.ParserException;
 import org.w3c.dom.Element;
 
+import java.io.IOException;
+
 /**
  * Creates a {@link NumericRangeFilter}. The table below specifies the required
  * attributes and the defaults if optional attributes are omitted. For more
@@ -84,80 +84,79 @@
  * <td>4</td>
  * </tr>
  * </table>
- * <p>
+ * <p/>
  * If an error occurs parsing the supplied <tt>lowerTerm</tt> or
  * <tt>upperTerm</tt> into the numeric type specified by <tt>type</tt>, then the
  * error will be silently ignored and the resulting filter will not match any
  * documents.
  */
 public class NumericRangeFilterBuilder implements FilterBuilder {
+  
-	private static final NoMatchFilter NO_MATCH_FILTER = new NoMatchFilter();
+  private static final NoMatchFilter NO_MATCH_FILTER = new NoMatchFilter();
 
-	private boolean strictMode = false;
+  private boolean strictMode = false;
 
-	/**
-	 * Specifies how this {@link NumericRangeFilterBuilder} will handle errors.
+  /**
+   * Specifies how this {@link NumericRangeFilterBuilder} will handle errors.
-	 * <p>
+   * <p/>
-	 * If this is set to true, {@link #getFilter(Element)} will throw a
-	 * {@link ParserException} if it is unable to parse the lowerTerm or upperTerm
-	 * into the appropriate numeric type. If this is set to false, then this
-	 * exception will be silently ignored and the resulting filter will not match
-	 * any documents.
+   * If this is set to true, {@link #getFilter(Element)} will throw a
+   * {@link ParserException} if it is unable to parse the lowerTerm or upperTerm
+   * into the appropriate numeric type. If this is set to false, then this
+   * exception will be silently ignored and the resulting filter will not match
+   * any documents.
-	 * <p>
+   * <p/>
-	 * Defaults to false.
-	 * 
-	 * @param strictMode
-	 */
-	public void setStrictMode(boolean strictMode) {
-		this.strictMode = strictMode;
-	}
+   * Defaults to false.
+   *
+   * @param strictMode
+   */
+  public void setStrictMode(boolean strictMode) {
+    this.strictMode = strictMode;
+  }
 
-	public Filter getFilter(Element e) throws ParserException {
-		String field = DOMUtils.getAttributeWithInheritanceOrFail(e, "fieldName");
-		String lowerTerm = DOMUtils.getAttributeOrFail(e, "lowerTerm");
-		String upperTerm = DOMUtils.getAttributeOrFail(e, "upperTerm");
-		boolean lowerInclusive = DOMUtils.getAttribute(e, "includeLower", true);
-		boolean upperInclusive = DOMUtils.getAttribute(e, "includeUpper", true);
+  public Filter getFilter(Element e) throws ParserException {
+    String field = DOMUtils.getAttributeWithInheritanceOrFail(e, "fieldName");
+    String lowerTerm = DOMUtils.getAttributeOrFail(e, "lowerTerm");
+    String upperTerm = DOMUtils.getAttributeOrFail(e, "upperTerm");
+    boolean lowerInclusive = DOMUtils.getAttribute(e, "includeLower", true);
+    boolean upperInclusive = DOMUtils.getAttribute(e, "includeUpper", true);
-		int precisionStep = DOMUtils.getAttribute(e, "precisionStep",  NumericUtils.PRECISION_STEP_DEFAULT);
+    int precisionStep = DOMUtils.getAttribute(e, "precisionStep", NumericUtils.PRECISION_STEP_DEFAULT);
 
-		String type = DOMUtils.getAttribute(e, "type", "int");
-		try {
-			Filter filter;
-			if (type.equalsIgnoreCase("int")) {
-				filter = NumericRangeFilter.newIntRange(field, precisionStep, Integer
-						.valueOf(lowerTerm), Integer.valueOf(upperTerm), lowerInclusive,
-						upperInclusive);
-			} else if (type.equalsIgnoreCase("long")) {
-				filter = NumericRangeFilter.newLongRange(field, precisionStep, Long
-						.valueOf(lowerTerm), Long.valueOf(upperTerm), lowerInclusive,
-						upperInclusive);
-			} else if (type.equalsIgnoreCase("double")) {
-				filter = NumericRangeFilter.newDoubleRange(field, precisionStep, Double
-						.valueOf(lowerTerm), Double.valueOf(upperTerm), lowerInclusive,
-						upperInclusive);
-			} else if (type.equalsIgnoreCase("float")) {
-				filter = NumericRangeFilter.newFloatRange(field, precisionStep, Float
-						.valueOf(lowerTerm), Float.valueOf(upperTerm), lowerInclusive,
-						upperInclusive);
-			} else {
+    String type = DOMUtils.getAttribute(e, "type", "int");
+    try {
+      Filter filter;
+      if (type.equalsIgnoreCase("int")) {
+        filter = NumericRangeFilter.newIntRange(field, precisionStep, Integer
+            .valueOf(lowerTerm), Integer.valueOf(upperTerm), lowerInclusive,
+            upperInclusive);
+      } else if (type.equalsIgnoreCase("long")) {
+        filter = NumericRangeFilter.newLongRange(field, precisionStep, Long
+            .valueOf(lowerTerm), Long.valueOf(upperTerm), lowerInclusive,
+            upperInclusive);
+      } else if (type.equalsIgnoreCase("double")) {
+        filter = NumericRangeFilter.newDoubleRange(field, precisionStep, Double
+            .valueOf(lowerTerm), Double.valueOf(upperTerm), lowerInclusive,
+            upperInclusive);
+      } else if (type.equalsIgnoreCase("float")) {
+        filter = NumericRangeFilter.newFloatRange(field, precisionStep, Float
+            .valueOf(lowerTerm), Float.valueOf(upperTerm), lowerInclusive,
+            upperInclusive);
+      } else {
-				throw new ParserException(
-						"type attribute must be one of: [long, int, double, float]");
+        throw new ParserException("type attribute must be one of: [long, int, double, float]");
-			}
-			return filter;
-		} catch (NumberFormatException nfe) {
-			if (strictMode) {
+      }
+      return filter;
+    } catch (NumberFormatException nfe) {
+      if (strictMode) {
-				throw new ParserException(
-						"Could not parse lowerTerm or upperTerm into a number", nfe);
+        throw new ParserException("Could not parse lowerTerm or upperTerm into a number", nfe);
-			}
-			return NO_MATCH_FILTER;
-		}
-	}
+      }
+      return NO_MATCH_FILTER;
+    }
+  }
 
-	static class NoMatchFilter extends Filter {
+  static class NoMatchFilter extends Filter {
 
-		@Override
-		public DocIdSet getDocIdSet(AtomicReaderContext context) throws IOException {
-			return null;
+    @Override
+    public DocIdSet getDocIdSet(AtomicReaderContext context) throws IOException {
+      return null;
 		}
 
 	}
Index: lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/DuplicateFilterBuilder.java
===================================================================
--- lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/DuplicateFilterBuilder.java	(revision 1145916)
+++ lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/DuplicateFilterBuilder.java	Thu Jul 14 17:02:40 NZST 2011
@@ -28,44 +28,33 @@
  */
 
 /**
- * 
+ *
  */
 public class DuplicateFilterBuilder implements FilterBuilder {
-	
+
-
-	public Filter getFilter(Element e) throws ParserException {
+  public Filter getFilter(Element e) throws ParserException {
-        String fieldName=DOMUtils.getAttributeWithInheritanceOrFail(e,"fieldName");
+    String fieldName = DOMUtils.getAttributeWithInheritanceOrFail(e, "fieldName");
-		DuplicateFilter df=new DuplicateFilter(fieldName);
+    DuplicateFilter df = new DuplicateFilter(fieldName);
+
-		String keepMode=DOMUtils.getAttribute(e,"keepMode","first");
+    String keepMode = DOMUtils.getAttribute(e, "keepMode", "first");
-		if(keepMode.equalsIgnoreCase("first"))
-		{
+    if (keepMode.equalsIgnoreCase("first")) {
-			df.setKeepMode(DuplicateFilter.KeepMode.KM_USE_FIRST_OCCURRENCE);
+      df.setKeepMode(DuplicateFilter.KeepMode.KM_USE_FIRST_OCCURRENCE);
-		}
-		else
-			if(keepMode.equalsIgnoreCase("last"))
-			{
+    } else if (keepMode.equalsIgnoreCase("last")) {
-				df.setKeepMode(DuplicateFilter.KeepMode.KM_USE_LAST_OCCURRENCE);
+      df.setKeepMode(DuplicateFilter.KeepMode.KM_USE_LAST_OCCURRENCE);
-			}
-			else
-			{
+    } else {
-				throw new ParserException("Illegal keepMode attribute in DuplicateFilter:"+keepMode);
+      throw new ParserException("Illegal keepMode attribute in DuplicateFilter:" + keepMode);
-			}
+    }
+
-		String processingMode=DOMUtils.getAttribute(e,"processingMode","full");
+    String processingMode = DOMUtils.getAttribute(e, "processingMode", "full");
-		if(processingMode.equalsIgnoreCase("full"))
-		{
+    if (processingMode.equalsIgnoreCase("full")) {
-			df.setProcessingMode(DuplicateFilter.ProcessingMode.PM_FULL_VALIDATION);
+      df.setProcessingMode(DuplicateFilter.ProcessingMode.PM_FULL_VALIDATION);
-		}
-		else
-			if(processingMode.equalsIgnoreCase("fast"))
-			{
+    } else if (processingMode.equalsIgnoreCase("fast")) {
-				df.setProcessingMode(DuplicateFilter.ProcessingMode.PM_FAST_INVALIDATION);
+      df.setProcessingMode(DuplicateFilter.ProcessingMode.PM_FAST_INVALIDATION);
-			}
-			else
-			{
+    } else {
-				throw new ParserException("Illegal processingMode attribute in DuplicateFilter:"+processingMode);
+      throw new ParserException("Illegal processingMode attribute in DuplicateFilter:" + processingMode);
-			}
-					
-		return df;
-	}
+    }
+
+    return df;
+  }
 
 }
Index: lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/SpanQueryBuilder.java
===================================================================
--- lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/SpanQueryBuilder.java	(revision 712922)
+++ lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/SpanQueryBuilder.java	Thu Jul 14 17:11:03 NZST 2011
@@ -20,9 +20,7 @@
 import org.apache.lucene.xmlparser.QueryBuilder;
 import org.w3c.dom.Element;
 
-
-public interface SpanQueryBuilder extends QueryBuilder{
+public interface SpanQueryBuilder extends QueryBuilder {
 	
 	public SpanQuery getSpanQuery(Element e) throws ParserException;
-
 }
Index: lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/BoostingQueryBuilder.java
===================================================================
--- lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/BoostingQueryBuilder.java	(revision 811070)
+++ lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/BoostingQueryBuilder.java	Thu Jul 14 17:15:25 NZST 2011
@@ -24,37 +24,32 @@
  */
 
 /**
- * 
+ *
  */
-public class BoostingQueryBuilder implements QueryBuilder
-{
+public class BoostingQueryBuilder implements QueryBuilder {
-	
+
-	private QueryBuilder factory;
-	float defaultBoost=0.01f;
+  private static float DEFAULT_BOOST = 0.01f;
-
+  
-	public BoostingQueryBuilder (QueryBuilder factory)
-	{
+  private final QueryBuilder factory;
+
+  public BoostingQueryBuilder(QueryBuilder factory) {
-		this.factory=factory;
+    this.factory = factory;
-	}
+  }
 
-	public Query getQuery(Element e) throws ParserException
-	{
-		
+  public Query getQuery(Element e) throws ParserException {
-        Element mainQueryElem=DOMUtils.getChildByTagOrFail(e,"Query");
+    Element mainQueryElem = DOMUtils.getChildByTagOrFail(e, "Query");
- 		mainQueryElem=DOMUtils.getFirstChildOrFail(mainQueryElem);
+    mainQueryElem = DOMUtils.getFirstChildOrFail(mainQueryElem);
-  		Query mainQuery=factory.getQuery(mainQueryElem);
+    Query mainQuery = factory.getQuery(mainQueryElem);
 
- 		Element boostQueryElem=DOMUtils.getChildByTagOrFail(e,"BoostQuery");
+    Element boostQueryElem = DOMUtils.getChildByTagOrFail(e, "BoostQuery");
-  		float boost=DOMUtils.getAttribute(boostQueryElem,"boost",defaultBoost);
+    float boost = DOMUtils.getAttribute(boostQueryElem, "boost", DEFAULT_BOOST);
- 		boostQueryElem=DOMUtils.getFirstChildOrFail(boostQueryElem);
+    boostQueryElem = DOMUtils.getFirstChildOrFail(boostQueryElem);
-  		Query boostQuery=factory.getQuery(boostQueryElem);
+    Query boostQuery = factory.getQuery(boostQueryElem);
-  		
+
-  		BoostingQuery bq = new BoostingQuery(mainQuery,boostQuery,boost);
+    BoostingQuery bq = new BoostingQuery(mainQuery, boostQuery, boost);
 
-  		bq.setBoost(DOMUtils.getAttribute(e,"boost",1.0f));
+    bq.setBoost(DOMUtils.getAttribute(e, "boost", 1.0f));
-		return bq;
+    return bq;
 
-	}
+  }
-
-
 }
Index: lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/CachedFilterBuilder.java
===================================================================
--- lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/CachedFilterBuilder.java	(revision 834414)
+++ lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/CachedFilterBuilder.java	Thu Jul 14 17:02:16 NZST 2011
@@ -3,19 +3,14 @@
  */
 package org.apache.lucene.xmlparser.builders;
 
-import java.util.Map.Entry;
-
 import org.apache.lucene.search.CachingWrapperFilter;
 import org.apache.lucene.search.Filter;
 import org.apache.lucene.search.Query;
 import org.apache.lucene.search.QueryWrapperFilter;
-import org.apache.lucene.xmlparser.DOMUtils;
-import org.apache.lucene.xmlparser.FilterBuilder;
-import org.apache.lucene.xmlparser.FilterBuilderFactory;
-import org.apache.lucene.xmlparser.ParserException;
-import org.apache.lucene.xmlparser.QueryBuilder;
-import org.apache.lucene.xmlparser.QueryBuilderFactory;
+import org.apache.lucene.xmlparser.*;
 import org.w3c.dom.Element;
+
+import java.util.Map;
 /**
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -32,99 +27,89 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 /**
- * Filters are cached in an LRU Cache keyed on the contained query or filter object. Using this will 
- * speed up overall performance for repeated uses of the same expensive query/filter. The sorts of 
- * queries/filters likely to benefit from caching need not necessarily be complex - e.g. simple 
- * TermQuerys with a large DF (document frequency) can be expensive	on large indexes. 
- * A good example of this might be a term query on a field with only 2 possible	values - 
- * "true" or "false". In a large index, querying or filtering on this field requires reading 
+ * Filters are cached in an LRU Cache keyed on the contained query or filter object. Using this will
+ * speed up overall performance for repeated uses of the same expensive query/filter. The sorts of
+ * queries/filters likely to benefit from caching need not necessarily be complex - e.g. simple
+ * TermQuerys with a large DF (document frequency) can be expensive	on large indexes.
+ * A good example of this might be a term query on a field with only 2 possible	values -
+ * "true" or "false". In a large index, querying or filtering on this field requires reading
  * millions	of document ids from disk which can more usefully be cached as a filter bitset.
- * 
+ * <p/>
  * For Queries/Filters to be cached and reused the object must implement hashcode and
  * equals methods correctly so that duplicate queries/filters can be detected in the cache.
- * 
+ * <p/>
- * The CoreParser.maxNumCachedFilters property can be used to control the size of the LRU 
+ * The CoreParser.maxNumCachedFilters property can be used to control the size of the LRU
  * Cache established during the construction of CoreParser instances.
- *
  */
 public class CachedFilterBuilder implements FilterBuilder {
 
-	private QueryBuilderFactory queryFactory;
-	private FilterBuilderFactory filterFactory;
+  private final QueryBuilderFactory queryFactory;
+  private final FilterBuilderFactory filterFactory;
-	
+
-    private  LRUCache<Object,Filter> filterCache = null;
+  private LRUCache<Object, Filter> filterCache = null;
 
-	private int cacheSize;
+  private final int cacheSize;
 
-	public CachedFilterBuilder(QueryBuilderFactory queryFactory, 
+  public CachedFilterBuilder(QueryBuilderFactory queryFactory,
-			FilterBuilderFactory filterFactory,int cacheSize)
-	{
+                             FilterBuilderFactory filterFactory,
+                             int cacheSize) {
-		this.queryFactory=queryFactory;
+    this.queryFactory = queryFactory;
-		this.filterFactory=filterFactory;
+    this.filterFactory = filterFactory;
-		this.cacheSize=cacheSize;
+    this.cacheSize = cacheSize;
-	}
+  }
 
-	public synchronized Filter getFilter(Element e) throws ParserException
-	{
-
+  public synchronized Filter getFilter(Element e) throws ParserException {
-		Element childElement = DOMUtils.getFirstChildOrFail(e);
+    Element childElement = DOMUtils.getFirstChildOrFail(e);
 
-		if (filterCache == null)
-		{
+    if (filterCache == null) {
-			filterCache = new LRUCache<Object,Filter>(cacheSize);
+      filterCache = new LRUCache<Object, Filter>(cacheSize);
-		}
+    }
 
-		// Test to see if child Element is a query or filter that needs to be
-		// cached
-		QueryBuilder qb = queryFactory.getQueryBuilder(childElement.getNodeName());
-		Object cacheKey = null;
-		Query q = null;
-		Filter f = null;
+    // Test to see if child Element is a query or filter that needs to be
+    // cached
+    QueryBuilder qb = queryFactory.getQueryBuilder(childElement.getNodeName());
+    Object cacheKey = null;
+    Query q = null;
+    Filter f = null;
-		if (qb != null)
-		{
+    if (qb != null) {
-			q = qb.getQuery(childElement);
-			cacheKey = q;
+      q = qb.getQuery(childElement);
+      cacheKey = q;
-		} else
-		{
+    } else {
-			f = filterFactory.getFilter(childElement);
-			cacheKey = f;
-		}
-		Filter cachedFilter = filterCache.get(cacheKey);
+      f = filterFactory.getFilter(childElement);
+      cacheKey = f;
+    }
+    Filter cachedFilter = filterCache.get(cacheKey);
-		if (cachedFilter != null)
-		{
+    if (cachedFilter != null) {
-			return cachedFilter; // cache hit
-		}
-		
-		//cache miss
+      return cachedFilter; // cache hit
+    }
+
+    //cache miss
-		if (qb != null)
-		{
+    if (qb != null) {
-			cachedFilter = new QueryWrapperFilter(q);
+      cachedFilter = new QueryWrapperFilter(q);
-		} else
-		{
+    } else {
-			cachedFilter = new CachingWrapperFilter(f);
-		}
+      cachedFilter = new CachingWrapperFilter(f);
+    }
 
-		filterCache.put(cacheKey, cachedFilter);
-		return cachedFilter;
-	}
-	
+    filterCache.put(cacheKey, cachedFilter);
+    return cachedFilter;
+  }
+
-	static class LRUCache<K,V> extends java.util.LinkedHashMap<K,V>
-	{
-	    public LRUCache(int maxsize)
-	    {
+  static class LRUCache<K, V> extends java.util.LinkedHashMap<K, V> {
+
+    public LRUCache(int maxsize) {
-	        super(maxsize * 4 / 3 + 1, 0.75f, true);
-	        this.maxsize = maxsize;
-	    }
+      super(maxsize * 4 / 3 + 1, 0.75f, true);
+      this.maxsize = maxsize;
+    }
 
-	    protected int maxsize;
+    protected int maxsize;
 
-	    @Override
+    @Override
-	    protected boolean removeEldestEntry(Entry<K,V> eldest)
-	    {
+    protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
-	        return size() > maxsize;
-	    }
+      return size() > maxsize;
+    }
 
-	}
+  }
 
 }
Index: lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/TermsQueryBuilder.java
===================================================================
--- lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/TermsQueryBuilder.java	(revision 1138058)
+++ lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/TermsQueryBuilder.java	Thu Jul 14 17:15:25 NZST 2011
@@ -1,8 +1,5 @@
 package org.apache.lucene.xmlparser.builders;
 
-import java.io.IOException;
-import java.io.StringReader;
-
 import org.apache.lucene.analysis.Analyzer;
 import org.apache.lucene.analysis.TokenStream;
 import org.apache.lucene.analysis.tokenattributes.TermToBytesRefAttribute;
@@ -17,6 +14,9 @@
 import org.apache.lucene.xmlparser.QueryBuilder;
 import org.w3c.dom.Element;
 
+import java.io.IOException;
+import java.io.StringReader;
+
 /**
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -33,52 +33,44 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 /**
  * Builds a BooleanQuery from all of the terms found in the XML element using the choice of analyzer
  */
 public class TermsQueryBuilder implements QueryBuilder {
 
-	Analyzer analyzer;
+  private final Analyzer analyzer;
 
-		
-	public TermsQueryBuilder(Analyzer analyzer)
-	{
+  public TermsQueryBuilder(Analyzer analyzer) {
-		this.analyzer = analyzer;
-	}
+    this.analyzer = analyzer;
+  }
 
-
-
-	public Query getQuery(Element e) throws ParserException {
+  public Query getQuery(Element e) throws ParserException {
-		
-        String fieldName=DOMUtils.getAttributeWithInheritanceOrFail(e,"fieldName");
+    String fieldName = DOMUtils.getAttributeWithInheritanceOrFail(e, "fieldName");
- 		String text=DOMUtils.getNonBlankTextOrFail(e);
+    String text = DOMUtils.getNonBlankTextOrFail(e);
- 		
+
-		BooleanQuery bq=new BooleanQuery(DOMUtils.getAttribute(e,"disableCoord",false));
+    BooleanQuery bq = new BooleanQuery(DOMUtils.getAttribute(e, "disableCoord", false));
-		bq.setMinimumNumberShouldMatch(DOMUtils.getAttribute(e,"minimumNumberShouldMatch",0));
+    bq.setMinimumNumberShouldMatch(DOMUtils.getAttribute(e, "minimumNumberShouldMatch", 0));
-		try
-		{
+    try {
-	    TokenStream ts = analyzer.reusableTokenStream(fieldName, new StringReader(text));
-		  TermToBytesRefAttribute termAtt = ts.addAttribute(TermToBytesRefAttribute.class);
-			Term term = null;
+      TokenStream ts = analyzer.reusableTokenStream(fieldName, new StringReader(text));
+      TermToBytesRefAttribute termAtt = ts.addAttribute(TermToBytesRefAttribute.class);
+      Term term = null;
       BytesRef bytes = termAtt.getBytesRef();
       ts.reset();
-			while (ts.incrementToken()) {
+      while (ts.incrementToken()) {
         termAtt.fillBytesRef();
         term = new Term(fieldName, new BytesRef(bytes));
-				bq.add(new BooleanClause(new TermQuery(term),BooleanClause.Occur.SHOULD));
+        bq.add(new BooleanClause(new TermQuery(term), BooleanClause.Occur.SHOULD));
-			}
-			ts.end();
-			ts.close();
-		} 
+      }
+      ts.end();
+      ts.close();
+    }
-		catch (IOException ioe)
-		{
-			throw new RuntimeException("Error constructing terms from index:"
-					+ ioe);
+    catch (IOException ioe) {
+      throw new RuntimeException("Error constructing terms from index:" + ioe);
-		}
+    }
-  		bq.setBoost(DOMUtils.getAttribute(e,"boost",1.0f));
 
+    bq.setBoost(DOMUtils.getAttribute(e, "boost", 1.0f));
-  		return bq;
+    return bq;
-		
-	}
+  }
 
 }
Index: lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/UserInputQueryBuilder.java
===================================================================
--- lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/UserInputQueryBuilder.java	(revision 1145016)
+++ lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/UserInputQueryBuilder.java	Thu Jul 14 17:15:25 NZST 2011
@@ -4,11 +4,11 @@
 import org.apache.lucene.queryparser.classic.ParseException;
 import org.apache.lucene.queryparser.classic.QueryParser;
 import org.apache.lucene.search.Query;
+import org.apache.lucene.util.Version;
 import org.apache.lucene.xmlparser.DOMUtils;
 import org.apache.lucene.xmlparser.ParserException;
 import org.apache.lucene.xmlparser.QueryBuilder;
 import org.w3c.dom.Element;
-import org.apache.lucene.util.Version;
 
 /**
  * Licensed to the Apache Software Foundation (ASF) under one or more
@@ -35,61 +35,59 @@
  */
 public class UserInputQueryBuilder implements QueryBuilder {
 
-	QueryParser unSafeParser;
+  private QueryParser unSafeParser;
-	private Analyzer analyzer;
-	private String defaultField;
-	
-	/**
-	 * This constructor has the disadvantage of not being able to change choice of default field name
+  private Analyzer analyzer;
+  private String defaultField;
+
+  /**
+   * This constructor has the disadvantage of not being able to change choice of default field name
+   *
-	 * @param parser thread un-safe query parser
-	 */
-	public UserInputQueryBuilder(QueryParser parser) {
-		this.unSafeParser = parser;
-	}
+   * @param parser thread un-safe query parser
+   */
+  public UserInputQueryBuilder(QueryParser parser) {
+    this.unSafeParser = parser;
+  }
 
-	public UserInputQueryBuilder(String defaultField, Analyzer analyzer) {
-		this.analyzer = analyzer;
-		this.defaultField = defaultField;
-	}
-	
-	/* (non-Javadoc)
-	 * @see org.apache.lucene.xmlparser.QueryObjectBuilder#process(org.w3c.dom.Element)
-	 */
+  public UserInputQueryBuilder(String defaultField, Analyzer analyzer) {
+    this.analyzer = analyzer;
+    this.defaultField = defaultField;
+  }
+
+  /* (non-Javadoc)
+    * @see org.apache.lucene.xmlparser.QueryObjectBuilder#process(org.w3c.dom.Element)
+    */
+
-	public Query getQuery(Element e) throws ParserException {
+  public Query getQuery(Element e) throws ParserException {
-		String text=DOMUtils.getText(e);
+    String text = DOMUtils.getText(e);
-		try {
-			Query q = null;
+    try {
+      Query q = null;
-			if(unSafeParser!=null)
-			{
+      if (unSafeParser != null) {
-				//synchronize on unsafe parser
+        //synchronize on unsafe parser
-				synchronized (unSafeParser)
-				{
+        synchronized (unSafeParser) {
-					q = unSafeParser.parse(text);
-				}
+          q = unSafeParser.parse(text);
+        }
-			}
-			else
-			{
+      } else {
-				String fieldName=DOMUtils.getAttribute(e, "fieldName", defaultField);
+        String fieldName = DOMUtils.getAttribute(e, "fieldName", defaultField);
-				//Create new parser
+        //Create new parser
-				QueryParser parser=createQueryParser(fieldName, analyzer);
+        QueryParser parser = createQueryParser(fieldName, analyzer);
-				q = parser.parse(text);				
-			}
+        q = parser.parse(text);
+      }
-			q.setBoost(DOMUtils.getAttribute(e,"boost",1.0f));
+      q.setBoost(DOMUtils.getAttribute(e, "boost", 1.0f));
-			return q;
-		} catch (ParseException e1) {
-			throw new ParserException(e1.getMessage());
-		}
-	}
-	
-	/**
-	 * Method to create a QueryParser - designed to be overridden
+      return q;
+    } catch (ParseException e1) {
+      throw new ParserException(e1.getMessage());
+    }
+  }
+
+  /**
+   * Method to create a QueryParser - designed to be overridden
+   *
-	 * @param fieldName
-	 * @param analyzer
-	 * @return QueryParser
-	 */
+   * @param fieldName
+   * @param analyzer
+   * @return QueryParser
+   */
-	protected QueryParser createQueryParser(String fieldName, Analyzer analyzer)
-	{
+  protected QueryParser createQueryParser(String fieldName, Analyzer analyzer) {
-		return new QueryParser(Version.LUCENE_CURRENT, fieldName,analyzer);
+    return new QueryParser(Version.LUCENE_CURRENT, fieldName, analyzer);
 	}
 
 }
Index: lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/FuzzyLikeThisQueryBuilder.java
===================================================================
--- lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/FuzzyLikeThisQueryBuilder.java	(revision 1024498)
+++ lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/FuzzyLikeThisQueryBuilder.java	Thu Jul 14 17:05:51 NZST 2011
@@ -28,40 +28,39 @@
  */
 
 /**
- * 
+ *
  */
-public class FuzzyLikeThisQueryBuilder implements QueryBuilder
-{
-	int defaultMaxNumTerms=50;
-	float defaultMinSimilarity=FuzzyQuery.defaultMinSimilarity;
-	int defaultPrefixLength=1;
-	boolean defaultIgnoreTF=false;
-	private Analyzer analyzer;
+public class FuzzyLikeThisQueryBuilder implements QueryBuilder {
-	
+
-	public FuzzyLikeThisQueryBuilder(Analyzer analyzer)
-	{
+  private static final int DEFAULT_MAX_NUM_TERMS = 50;
+  private static final float DEFAULT_MIN_SIMILARITY = FuzzyQuery.defaultMinSimilarity;
+  private static final int DEFAULT_PREFIX_LENGTH = 1;
+  private static final boolean DEFAULT_IGNORE_TF = false;
+
+  private final Analyzer analyzer;
+
+  public FuzzyLikeThisQueryBuilder(Analyzer analyzer) {
-		this.analyzer=analyzer;
+    this.analyzer = analyzer;
-	}
+  }
 
-	public Query getQuery(Element e) throws ParserException
-	{
+  public Query getQuery(Element e) throws ParserException {
-		NodeList nl = e.getElementsByTagName("Field");
+    NodeList nl = e.getElementsByTagName("Field");
-		int maxNumTerms=DOMUtils.getAttribute(e,"maxNumTerms",defaultMaxNumTerms);
+    int maxNumTerms = DOMUtils.getAttribute(e, "maxNumTerms", DEFAULT_MAX_NUM_TERMS);
-		FuzzyLikeThisQuery fbq=new FuzzyLikeThisQuery(maxNumTerms,analyzer);
+    FuzzyLikeThisQuery fbq = new FuzzyLikeThisQuery(maxNumTerms, analyzer);
-		fbq.setIgnoreTF(DOMUtils.getAttribute(e,"ignoreTF",defaultIgnoreTF));
-		for(int i=0;i<nl.getLength();i++)
-		{
+    fbq.setIgnoreTF(DOMUtils.getAttribute(e, "ignoreTF", DEFAULT_IGNORE_TF));
+
+    for (int i = 0; i < nl.getLength(); i++) {
-			Element fieldElem=(Element) nl.item(i);
+      Element fieldElem = (Element) nl.item(i);
-			float minSimilarity=DOMUtils.getAttribute(fieldElem,"minSimilarity",defaultMinSimilarity);
-			int prefixLength=DOMUtils.getAttribute(fieldElem,"prefixLength",defaultPrefixLength);
+      float minSimilarity = DOMUtils.getAttribute(fieldElem, "minSimilarity", DEFAULT_MIN_SIMILARITY);
+      int prefixLength = DOMUtils.getAttribute(fieldElem, "prefixLength", DEFAULT_PREFIX_LENGTH);
-			String fieldName=DOMUtils.getAttributeWithInheritance(fieldElem,"fieldName");
+      String fieldName = DOMUtils.getAttributeWithInheritance(fieldElem, "fieldName");
-			
+
-			String value=DOMUtils.getText(fieldElem);
+      String value = DOMUtils.getText(fieldElem);
-			fbq.addTerms(value,fieldName,minSimilarity,prefixLength);
+      fbq.addTerms(value, fieldName, minSimilarity, prefixLength);
-		}
+    }
-		fbq.setBoost(DOMUtils.getAttribute(e,"boost",1.0f));
 
+    fbq.setBoost(DOMUtils.getAttribute(e, "boost", 1.0f));
-		return fbq;
-	}
+    return fbq;
+  }
 
 }
Index: lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/TermsFilterBuilder.java
===================================================================
--- lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/TermsFilterBuilder.java	(revision 1138058)
+++ lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/TermsFilterBuilder.java	Thu Jul 14 17:12:06 NZST 2011
@@ -1,8 +1,5 @@
 package org.apache.lucene.xmlparser.builders;
 
-import java.io.IOException;
-import java.io.StringReader;
-
 import org.apache.lucene.analysis.Analyzer;
 import org.apache.lucene.analysis.TokenStream;
 import org.apache.lucene.analysis.tokenattributes.TermToBytesRefAttribute;
@@ -15,6 +12,9 @@
 import org.apache.lucene.xmlparser.ParserException;
 import org.w3c.dom.Element;
 
+import java.io.IOException;
+import java.io.StringReader;
+
 /**
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -33,51 +33,46 @@
  */
 
 /**
- * 
+ *
  */
-public class TermsFilterBuilder implements FilterBuilder
-{
-	Analyzer analyzer;
+public class TermsFilterBuilder implements FilterBuilder {
-	
+
+  private final Analyzer analyzer;
+
-	/**
-	 * @param analyzer
-	 */
+  /**
+   * @param analyzer
+   */
-	public TermsFilterBuilder(Analyzer analyzer)
-	{
+  public TermsFilterBuilder(Analyzer analyzer) {
-		this.analyzer = analyzer;
-	}
-	
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.apache.lucene.xmlparser.FilterBuilder#process(org.w3c.dom.Element)
-	 */
+    this.analyzer = analyzer;
+  }
+
+  /*
+    * (non-Javadoc)
+    *
+    * @see org.apache.lucene.xmlparser.FilterBuilder#process(org.w3c.dom.Element)
+    */
-	public Filter getFilter(Element e) throws ParserException
-	{
+  public Filter getFilter(Element e) throws ParserException {
-		TermsFilter tf = new TermsFilter();
-		String text = DOMUtils.getNonBlankTextOrFail(e);
-		String fieldName = DOMUtils.getAttributeWithInheritanceOrFail(e, "fieldName");
-    
+    TermsFilter tf = new TermsFilter();
+    String text = DOMUtils.getNonBlankTextOrFail(e);
+    String fieldName = DOMUtils.getAttributeWithInheritanceOrFail(e, "fieldName");
+
-		try
-		{
+    try {
-	    TokenStream ts = analyzer.reusableTokenStream(fieldName, new StringReader(text));
-	    TermToBytesRefAttribute termAtt = ts.addAttribute(TermToBytesRefAttribute.class);
-			Term term = null;
+      TokenStream ts = analyzer.reusableTokenStream(fieldName, new StringReader(text));
+      TermToBytesRefAttribute termAtt = ts.addAttribute(TermToBytesRefAttribute.class);
+      Term term = null;
       BytesRef bytes = termAtt.getBytesRef();
       ts.reset();
-	      while (ts.incrementToken()) {
-	        termAtt.fillBytesRef();
-				term = new Term(fieldName, new BytesRef(bytes));
-				tf.addTerm(term);
-			}
-	    ts.end();
-	    ts.close();
-		} 
+      while (ts.incrementToken()) {
+        termAtt.fillBytesRef();
+        term = new Term(fieldName, new BytesRef(bytes));
+        tf.addTerm(term);
+      }
+      ts.end();
+      ts.close();
+    }
-		catch (IOException ioe)
-		{
-			throw new RuntimeException("Error constructing terms from index:"
-					+ ioe);
+    catch (IOException ioe) {
+      throw new RuntimeException("Error constructing terms from index:" + ioe);
-		}
-		return tf;
-	}
+    }
+    return tf;
+  }
 }
Index: lucene/contrib/xml-query-parser/src/test/org/apache/lucene/xmlparser/TestParser.java
===================================================================
--- lucene/contrib/xml-query-parser/src/test/org/apache/lucene/xmlparser/TestParser.java	(revision 1098303)
+++ lucene/contrib/xml-query-parser/src/test/org/apache/lucene/xmlparser/TestParser.java	Thu Jul 14 17:19:09 NZST 2011
@@ -1,10 +1,5 @@
 package org.apache.lucene.xmlparser;
 
-import java.io.BufferedReader;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-
 import org.apache.lucene.analysis.Analyzer;
 import org.apache.lucene.analysis.MockAnalyzer;
 import org.apache.lucene.analysis.MockTokenFilter;
@@ -18,11 +13,17 @@
 import org.apache.lucene.search.ScoreDoc;
 import org.apache.lucene.search.TopDocs;
 import org.apache.lucene.store.Directory;
-import org.apache.lucene.util.Version;
 import org.apache.lucene.util.LuceneTestCase;
+import org.apache.lucene.util.Version;
 import org.junit.AfterClass;
 import org.junit.Assume;
 import org.junit.BeforeClass;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+
 /**
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -30,9 +31,9 @@
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
- *
+ * <p/>
- *     http://www.apache.org/licenses/LICENSE-2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
- *
+ * <p/>
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -41,200 +42,185 @@
  */
 
 public class TestParser extends LuceneTestCase {
+
-	private static CoreParser builder;
-	private static Directory dir;
-	private static IndexReader reader;
-	private static IndexSearcher searcher;
+  private static CoreParser builder;
+  private static Directory dir;
+  private static IndexReader reader;
+  private static IndexSearcher searcher;
 
-	@BeforeClass
-	public static void beforeClass() throws Exception {
-	  // TODO: rewrite test (this needs to set QueryParser.enablePositionIncrements, too, for work with CURRENT):
+  @BeforeClass
+  public static void beforeClass() throws Exception {
+    // TODO: rewrite test (this needs to set QueryParser.enablePositionIncrements, too, for work with CURRENT):
-	  Analyzer analyzer=new MockAnalyzer(random, MockTokenizer.WHITESPACE, true, MockTokenFilter.ENGLISH_STOPSET, false); 
+    Analyzer analyzer = new MockAnalyzer(random, MockTokenizer.WHITESPACE, true, MockTokenFilter.ENGLISH_STOPSET, false);
     //initialize the parser
-	  builder=new CorePlusExtensionsParser("contents",analyzer);
+    builder = new CorePlusExtensionsParser("contents", analyzer);
-		
-			BufferedReader d = new BufferedReader(new InputStreamReader(TestParser.class.getResourceAsStream("reuters21578.txt"))); 
+
+    BufferedReader d = new BufferedReader(new InputStreamReader(TestParser.class.getResourceAsStream("reuters21578.txt")));
-			dir=newDirectory();
+    dir = newDirectory();
-			IndexWriter writer = new IndexWriter(dir, newIndexWriterConfig(Version.LUCENE_40, analyzer));
-			String line = d.readLine();		
+    IndexWriter writer = new IndexWriter(dir, newIndexWriterConfig(Version.LUCENE_40, analyzer));
+    String line = d.readLine();
-			while(line!=null)
-			{
+    while (line != null) {
-				int endOfDate=line.indexOf('\t');
+      int endOfDate = line.indexOf('\t');
-				String date=line.substring(0,endOfDate).trim();
+      String date = line.substring(0, endOfDate).trim();
-				String content=line.substring(endOfDate).trim();
+      String content = line.substring(endOfDate).trim();
-				org.apache.lucene.document.Document doc =new org.apache.lucene.document.Document();
+      org.apache.lucene.document.Document doc = new org.apache.lucene.document.Document();
-				doc.add(newField("date",date,Field.Store.YES,Field.Index.ANALYZED));
+      doc.add(newField("date", date, Field.Store.YES, Field.Index.ANALYZED));
-				doc.add(newField("contents",content,Field.Store.YES,Field.Index.ANALYZED));
+      doc.add(newField("contents", content, Field.Store.YES, Field.Index.ANALYZED));
-				NumericField numericField = new NumericField("date2");
-				numericField.setIntValue(Integer.valueOf(date));
-				doc.add(numericField);
-				writer.addDocument(doc);
+      NumericField numericField = new NumericField("date2");
+      numericField.setIntValue(Integer.valueOf(date));
+      doc.add(numericField);
+      writer.addDocument(doc);
-				line=d.readLine();
+      line = d.readLine();
-			}			
-			d.close();
-      writer.close();
+    }
+    d.close();
+    writer.close();
-		reader=IndexReader.open(dir, true);
+    reader = IndexReader.open(dir, true);
-		searcher=newSearcher(reader);
+    searcher = newSearcher(reader);
-		
-	}
-	
+
+  }
+
-	
-	
-	
-	@AfterClass
-	public static void afterClass() throws Exception {
-		reader.close();
-		searcher.close();
-		dir.close();
-		reader = null;
-		searcher = null;
-		dir = null;
-		builder = null;
-	}
-	
+  @AfterClass
+  public static void afterClass() throws Exception {
+    reader.close();
+    searcher.close();
+    dir.close();
+    reader = null;
+    searcher = null;
+    dir = null;
+    builder = null;
+  }
+
-	public void testSimpleXML() throws ParserException, IOException
-	{
+  public void testSimpleXML() throws ParserException, IOException {
-			Query q=parse("TermQuery.xml");
+    Query q = parse("TermQuery.xml");
-			dumpResults("TermQuery", q, 5);
-	}
+    dumpResults("TermQuery", q, 5);
+  }
-	public void testSimpleTermsQueryXML() throws ParserException, IOException
-	{
+
+  public void testSimpleTermsQueryXML() throws ParserException, IOException {
-			Query q=parse("TermsQuery.xml");
+    Query q = parse("TermsQuery.xml");
-			dumpResults("TermsQuery", q, 5);
-	}
+    dumpResults("TermsQuery", q, 5);
+  }
-	public void testBooleanQueryXML() throws ParserException, IOException
-	{
+
+  public void testBooleanQueryXML() throws ParserException, IOException {
-			Query q=parse("BooleanQuery.xml");
+    Query q = parse("BooleanQuery.xml");
-			dumpResults("BooleanQuery", q, 5);
-	}
+    dumpResults("BooleanQuery", q, 5);
+  }
-	public void testRangeFilterQueryXML() throws ParserException, IOException
-	{
+
+  public void testRangeFilterQueryXML() throws ParserException, IOException {
-			Query q=parse("RangeFilterQuery.xml");
+    Query q = parse("RangeFilterQuery.xml");
-			dumpResults("RangeFilter", q, 5);
-	}
+    dumpResults("RangeFilter", q, 5);
+  }
-	public void testUserQueryXML() throws ParserException, IOException
-	{
+
+  public void testUserQueryXML() throws ParserException, IOException {
-			Query q=parse("UserInputQuery.xml");
+    Query q = parse("UserInputQuery.xml");
-			dumpResults("UserInput with Filter", q, 5);
-	}
-	
+    dumpResults("UserInput with Filter", q, 5);
+  }
+
-	public void testCustomFieldUserQueryXML() throws ParserException, IOException
-	{
+  public void testCustomFieldUserQueryXML() throws ParserException, IOException {
-			Query q=parse("UserInputQueryCustomField.xml");
+    Query q = parse("UserInputQueryCustomField.xml");
-			int h = searcher.search(q, null, 1000).totalHits;
+    int h = searcher.search(q, null, 1000).totalHits;
-			assertEquals("UserInputQueryCustomField should produce 0 result ", 0,h);
+    assertEquals("UserInputQueryCustomField should produce 0 result ", 0, h);
-	}
-	
+  }
+
-	public void testLikeThisQueryXML() throws Exception
-	{
+  public void testLikeThisQueryXML() throws Exception {
-			Query q=parse("LikeThisQuery.xml");
+    Query q = parse("LikeThisQuery.xml");
-			dumpResults("like this", q, 5);
-	}
+    dumpResults("like this", q, 5);
+  }
-	public void testBoostingQueryXML() throws Exception
-	{
+
+  public void testBoostingQueryXML() throws Exception {
-			Query q=parse("BoostingQuery.xml");
+    Query q = parse("BoostingQuery.xml");
-			dumpResults("boosting ",q, 5);
+    dumpResults("boosting ", q, 5);
-	}
+  }
-	public void testFuzzyLikeThisQueryXML() throws Exception
-	{
+
+  public void testFuzzyLikeThisQueryXML() throws Exception {
-			Query q=parse("FuzzyLikeThisQuery.xml");
+    Query q = parse("FuzzyLikeThisQuery.xml");
-			//show rewritten fuzzyLikeThisQuery - see what is being matched on
+    //show rewritten fuzzyLikeThisQuery - see what is being matched on
-			if(VERBOSE)
-			{
+    if (VERBOSE) {
-				System.out.println(q.rewrite(reader));
-			}
-			dumpResults("FuzzyLikeThis", q, 5);
-	}
+      System.out.println(q.rewrite(reader));
+    }
+    dumpResults("FuzzyLikeThis", q, 5);
+  }
-	public void testTermsFilterXML() throws Exception
-	{
+
+  public void testTermsFilterXML() throws Exception {
-			Query q=parse("TermsFilterQuery.xml");
+    Query q = parse("TermsFilterQuery.xml");
-			dumpResults("Terms Filter",q, 5);
+    dumpResults("Terms Filter", q, 5);
-	}
+  }
-  public void testBoostingTermQueryXML() throws Exception
-	{
+
+  public void testBoostingTermQueryXML() throws Exception {
-			Query q=parse("BoostingTermQuery.xml");
+    Query q = parse("BoostingTermQuery.xml");
-			dumpResults("BoostingTermQuery",q, 5);
+    dumpResults("BoostingTermQuery", q, 5);
-	}
+  }
-  public void testSpanTermXML() throws Exception
-	{
+
+  public void testSpanTermXML() throws Exception {
-			Query q=parse("SpanQuery.xml");
+    Query q = parse("SpanQuery.xml");
-			dumpResults("Span Query",q, 5);
+    dumpResults("Span Query", q, 5);
-	}
+  }
-	public void testConstantScoreQueryXML() throws Exception
-	{
+
+  public void testConstantScoreQueryXML() throws Exception {
-			Query q=parse("ConstantScoreQuery.xml");
+    Query q = parse("ConstantScoreQuery.xml");
-			dumpResults("ConstantScoreQuery",q, 5);
+    dumpResults("ConstantScoreQuery", q, 5);
-	}
+  }
-	public void testMatchAllDocsPlusFilterXML() throws ParserException, IOException
-	{
+
+  public void testMatchAllDocsPlusFilterXML() throws ParserException, IOException {
-			Query q=parse("MatchAllDocsQuery.xml");
+    Query q = parse("MatchAllDocsQuery.xml");
-			dumpResults("MatchAllDocsQuery with range filter", q, 5);
-	}
+    dumpResults("MatchAllDocsQuery with range filter", q, 5);
+  }
-	public void testBooleanFilterXML() throws ParserException, IOException
-	{
+
+  public void testBooleanFilterXML() throws ParserException, IOException {
-			Query q=parse("BooleanFilter.xml");
+    Query q = parse("BooleanFilter.xml");
-			dumpResults("Boolean filter", q, 5);
-	}
+    dumpResults("Boolean filter", q, 5);
+  }
-	public void testNestedBooleanQuery() throws ParserException, IOException
-	{
+
+  public void testNestedBooleanQuery() throws ParserException, IOException {
-			Query q=parse("NestedBooleanQuery.xml");
+    Query q = parse("NestedBooleanQuery.xml");
-			dumpResults("Nested Boolean query", q, 5);
-	}
+    dumpResults("Nested Boolean query", q, 5);
+  }
-	public void testCachedFilterXML() throws ParserException, IOException
-	{
+
+  public void testCachedFilterXML() throws ParserException, IOException {
-			Query q=parse("CachedFilter.xml");
+    Query q = parse("CachedFilter.xml");
-			dumpResults("Cached filter", q, 5);
-	}
+    dumpResults("Cached filter", q, 5);
+  }
-	public void testDuplicateFilterQueryXML() throws ParserException, IOException
-	{
+
+  public void testDuplicateFilterQueryXML() throws ParserException, IOException {
-      Assume.assumeTrue(searcher.getIndexReader().getSequentialSubReaders() == null || 
-                        searcher.getIndexReader().getSequentialSubReaders().length == 1);
+    Assume.assumeTrue(searcher.getIndexReader().getSequentialSubReaders() == null ||
+        searcher.getIndexReader().getSequentialSubReaders().length == 1);
-			Query q=parse("DuplicateFilterQuery.xml");
+    Query q = parse("DuplicateFilterQuery.xml");
-			int h = searcher.search(q, null, 1000).totalHits;
+    int h = searcher.search(q, null, 1000).totalHits;
-			assertEquals("DuplicateFilterQuery should produce 1 result ", 1,h);
+    assertEquals("DuplicateFilterQuery should produce 1 result ", 1, h);
-	}
-	
+  }
+
-	public void testNumericRangeFilterQueryXML() throws ParserException, IOException
-	{
+  public void testNumericRangeFilterQueryXML() throws ParserException, IOException {
-			Query q=parse("NumericRangeFilterQuery.xml");
+    Query q = parse("NumericRangeFilterQuery.xml");
-			dumpResults("NumericRangeFilter", q, 5);
-	}
-	
+    dumpResults("NumericRangeFilter", q, 5);
+  }
+
-	public void testNumericRangeQueryQueryXML() throws ParserException, IOException
-	{
+  public void testNumericRangeQueryQueryXML() throws ParserException, IOException {
-			Query q=parse("NumericRangeQueryQuery.xml");
+    Query q = parse("NumericRangeQueryQuery.xml");
-			dumpResults("NumericRangeQuery", q, 5);
-	}
-	
+    dumpResults("NumericRangeQuery", q, 5);
+  }
+
-
-
-	//================= Helper methods ===================================
+  //================= Helper methods ===================================
-	private Query parse(String xmlFileName) throws ParserException, IOException
-	{
+
+  private Query parse(String xmlFileName) throws ParserException, IOException {
-		InputStream xmlStream=TestParser.class.getResourceAsStream(xmlFileName);
+    InputStream xmlStream = TestParser.class.getResourceAsStream(xmlFileName);
-		Query result=builder.parse(xmlStream);
+    Query result = builder.parse(xmlStream);
-		xmlStream.close();
-		return result;
-	}
+    xmlStream.close();
+    return result;
+  }
-	private void dumpResults(String qType,Query q, int numDocs) throws IOException
-	{
+
+  private void dumpResults(String qType, Query q, int numDocs) throws IOException {
-                if (VERBOSE) {
-                  System.out.println("TEST: query=" + q);
-                }
-                TopDocs hits = searcher.search(q, null, numDocs);
+    if (VERBOSE) {
+      System.out.println("TEST: query=" + q);
+    }
+    TopDocs hits = searcher.search(q, null, numDocs);
-		assertTrue(qType +" should produce results ", hits.totalHits>0);
+    assertTrue(qType + " should produce results ", hits.totalHits > 0);
-		if(VERBOSE)
-		{
+    if (VERBOSE) {
-			System.out.println("========="+qType+"============");
+      System.out.println("=========" + qType + "============");
-			ScoreDoc[] scoreDocs = hits.scoreDocs;
+      ScoreDoc[] scoreDocs = hits.scoreDocs;
-			for(int i=0;i<Math.min(numDocs,hits.totalHits);i++)
-			{
+      for (int i = 0; i < Math.min(numDocs, hits.totalHits); i++) {
-				org.apache.lucene.document.Document ldoc=searcher.doc(scoreDocs[i].doc);
+        org.apache.lucene.document.Document ldoc = searcher.doc(scoreDocs[i].doc);
-				System.out.println("["+ldoc.get("date")+"]"+ldoc.get("contents"));
+        System.out.println("[" + ldoc.get("date") + "]" + ldoc.get("contents"));
-			}
-			System.out.println();
-		}
-	}
+      }
+      System.out.println();
+    }
+  }
-	
-
 }
Index: lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/ParserException.java
===================================================================
--- lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/ParserException.java	(revision 811070)
+++ lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/ParserException.java	Thu Jul 14 16:58:10 NZST 2011
@@ -30,12 +30,14 @@
 	public ParserException() {
 		super();
 	}
+
 	/**
 	 * @param message
 	 */
 	public ParserException(String message) {
 		super(message);
 	}
+
 	/**
 	 * @param message
 	 * @param cause
@@ -43,6 +45,7 @@
 	public ParserException(String message, Throwable cause) {
 		super(message, cause);
 	}
+
 	/**
 	 * @param cause
 	 */
Index: lucene/contrib/xml-query-parser/src/test/org/apache/lucene/xmlparser/builders/TestNumericRangeQueryBuilder.java
===================================================================
--- lucene/contrib/xml-query-parser/src/test/org/apache/lucene/xmlparser/builders/TestNumericRangeQueryBuilder.java	(revision 1003877)
+++ lucene/contrib/xml-query-parser/src/test/org/apache/lucene/xmlparser/builders/TestNumericRangeQueryBuilder.java	Thu Jul 14 17:19:09 NZST 2011
@@ -17,161 +17,162 @@
  * limitations under the License.
  */
 
-import java.io.ByteArrayInputStream;
-import java.io.IOException;
-import java.io.InputStream;
-
-import javax.xml.parsers.DocumentBuilder;
-import javax.xml.parsers.DocumentBuilderFactory;
-import javax.xml.parsers.ParserConfigurationException;
-
-import org.apache.lucene.util.LuceneTestCase;
-
 import org.apache.lucene.search.NumericRangeQuery;
 import org.apache.lucene.search.Query;
+import org.apache.lucene.util.LuceneTestCase;
 import org.apache.lucene.xmlparser.ParserException;
 import org.w3c.dom.Document;
 import org.xml.sax.SAXException;
 
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
 public class TestNumericRangeQueryBuilder extends LuceneTestCase {
 
-	public void testGetFilterHandleNumericParseErrorStrict() throws Exception {
-		NumericRangeQueryBuilder filterBuilder = new NumericRangeQueryBuilder();
+  public void testGetFilterHandleNumericParseErrorStrict() throws Exception {
+    NumericRangeQueryBuilder filterBuilder = new NumericRangeQueryBuilder();
 
-		String xml = "<NumericRangeQuery fieldName='AGE' type='int' lowerTerm='-1' upperTerm='NaN'/>";
-		Document doc = getDocumentFromString(xml);
-		try {
-			filterBuilder.getQuery(doc.getDocumentElement());
-		} catch (ParserException e) {
-			return;
-		}
-		fail("Expected to throw " + ParserException.class);
-	}
+    String xml = "<NumericRangeQuery fieldName='AGE' type='int' lowerTerm='-1' upperTerm='NaN'/>";
+    Document doc = getDocumentFromString(xml);
+    try {
+      filterBuilder.getQuery(doc.getDocumentElement());
+    } catch (ParserException e) {
+      return;
+    }
+    fail("Expected to throw " + ParserException.class);
+  }
 
+  @SuppressWarnings("unchecked")
-	public void testGetFilterInt() throws Exception {
-		NumericRangeQueryBuilder filterBuilder = new NumericRangeQueryBuilder();
+  public void testGetFilterInt() throws Exception {
+    NumericRangeQueryBuilder filterBuilder = new NumericRangeQueryBuilder();
 
-		String xml = "<NumericRangeQuery fieldName='AGE' type='int' lowerTerm='-1' upperTerm='10'/>";
-		Document doc = getDocumentFromString(xml);
-		Query filter = filterBuilder.getQuery(doc.getDocumentElement());
-		assertTrue(filter instanceof NumericRangeQuery<?>);
+    String xml = "<NumericRangeQuery fieldName='AGE' type='int' lowerTerm='-1' upperTerm='10'/>";
+    Document doc = getDocumentFromString(xml);
+    Query filter = filterBuilder.getQuery(doc.getDocumentElement());
+    assertTrue(filter instanceof NumericRangeQuery<?>);
-		@SuppressWarnings("unchecked")
+
-		NumericRangeQuery<Integer> numRangeFilter = (NumericRangeQuery<Integer>) filter;
-		assertEquals(Integer.valueOf(-1), numRangeFilter.getMin());
-		assertEquals(Integer.valueOf(10), numRangeFilter.getMax());
-		assertEquals("AGE", numRangeFilter.getField());
-		assertTrue(numRangeFilter.includesMin());
-		assertTrue(numRangeFilter.includesMax());
+    NumericRangeQuery<Integer> numRangeFilter = (NumericRangeQuery<Integer>) filter;
+    assertEquals(Integer.valueOf(-1), numRangeFilter.getMin());
+    assertEquals(Integer.valueOf(10), numRangeFilter.getMax());
+    assertEquals("AGE", numRangeFilter.getField());
+    assertTrue(numRangeFilter.includesMin());
+    assertTrue(numRangeFilter.includesMax());
 
-		String xml2 = "<NumericRangeQuery fieldName='AGE' type='int' lowerTerm='-1' upperTerm='10' includeUpper='false'/>";
-		Document doc2 = getDocumentFromString(xml2);
-		Query filter2 = filterBuilder.getQuery(doc2.getDocumentElement());
-		assertTrue(filter2 instanceof NumericRangeQuery<?>);
+    String xml2 = "<NumericRangeQuery fieldName='AGE' type='int' lowerTerm='-1' upperTerm='10' includeUpper='false'/>";
+    Document doc2 = getDocumentFromString(xml2);
+    Query filter2 = filterBuilder.getQuery(doc2.getDocumentElement());
+    assertTrue(filter2 instanceof NumericRangeQuery<?>);
-		@SuppressWarnings("unchecked")
+
-		NumericRangeQuery<Integer> numRangeFilter2 = (NumericRangeQuery) filter2;
-		assertEquals(Integer.valueOf(-1), numRangeFilter2.getMin());
-		assertEquals(Integer.valueOf(10), numRangeFilter2.getMax());
-		assertEquals("AGE", numRangeFilter2.getField());
-		assertTrue(numRangeFilter2.includesMin());
-		assertFalse(numRangeFilter2.includesMax());
-	}
+    NumericRangeQuery<Integer> numRangeFilter2 = (NumericRangeQuery) filter2;
+    assertEquals(Integer.valueOf(-1), numRangeFilter2.getMin());
+    assertEquals(Integer.valueOf(10), numRangeFilter2.getMax());
+    assertEquals("AGE", numRangeFilter2.getField());
+    assertTrue(numRangeFilter2.includesMin());
+    assertFalse(numRangeFilter2.includesMax());
+  }
 
+  @SuppressWarnings("unchecked")
-	public void testGetFilterLong() throws Exception {
-		NumericRangeQueryBuilder filterBuilder = new NumericRangeQueryBuilder();
+  public void testGetFilterLong() throws Exception {
+    NumericRangeQueryBuilder filterBuilder = new NumericRangeQueryBuilder();
 
-		String xml = "<NumericRangeQuery fieldName='AGE' type='LoNg' lowerTerm='-2321' upperTerm='60000000'/>";
-		Document doc = getDocumentFromString(xml);
-		Query filter = filterBuilder.getQuery(doc.getDocumentElement());
-		assertTrue(filter instanceof NumericRangeQuery<?>);
+    String xml = "<NumericRangeQuery fieldName='AGE' type='LoNg' lowerTerm='-2321' upperTerm='60000000'/>";
+    Document doc = getDocumentFromString(xml);
+    Query filter = filterBuilder.getQuery(doc.getDocumentElement());
+    assertTrue(filter instanceof NumericRangeQuery<?>);
-		@SuppressWarnings("unchecked")
-		NumericRangeQuery<Long> numRangeFilter = (NumericRangeQuery) filter;
-		assertEquals(Long.valueOf(-2321L), numRangeFilter.getMin());
-		assertEquals(Long.valueOf(60000000L), numRangeFilter.getMax());
-		assertEquals("AGE", numRangeFilter.getField());
-		assertTrue(numRangeFilter.includesMin());
-		assertTrue(numRangeFilter.includesMax());
+    NumericRangeQuery<Long> numRangeFilter = (NumericRangeQuery) filter;
+    assertEquals(Long.valueOf(-2321L), numRangeFilter.getMin());
+    assertEquals(Long.valueOf(60000000L), numRangeFilter.getMax());
+    assertEquals("AGE", numRangeFilter.getField());
+    assertTrue(numRangeFilter.includesMin());
+    assertTrue(numRangeFilter.includesMax());
 
-		String xml2 = "<NumericRangeQuery fieldName='AGE' type='LoNg' lowerTerm='-2321' upperTerm='60000000' includeUpper='false'/>";
-		Document doc2 = getDocumentFromString(xml2);
-		Query filter2 = filterBuilder.getQuery(doc2.getDocumentElement());
-		assertTrue(filter2 instanceof NumericRangeQuery<?>);
+    String xml2 = "<NumericRangeQuery fieldName='AGE' type='LoNg' lowerTerm='-2321' upperTerm='60000000' includeUpper='false'/>";
+    Document doc2 = getDocumentFromString(xml2);
+    Query filter2 = filterBuilder.getQuery(doc2.getDocumentElement());
+    assertTrue(filter2 instanceof NumericRangeQuery<?>);
-		@SuppressWarnings("unchecked")
+
-		NumericRangeQuery<Long> numRangeFilter2 = (NumericRangeQuery) filter2;
-		assertEquals(Long.valueOf(-2321L), numRangeFilter2.getMin());
-		assertEquals(Long.valueOf(60000000L), numRangeFilter2.getMax());
-		assertEquals("AGE", numRangeFilter2.getField());
-		assertTrue(numRangeFilter2.includesMin());
-		assertFalse(numRangeFilter2.includesMax());
-	}
+    NumericRangeQuery<Long> numRangeFilter2 = (NumericRangeQuery) filter2;
+    assertEquals(Long.valueOf(-2321L), numRangeFilter2.getMin());
+    assertEquals(Long.valueOf(60000000L), numRangeFilter2.getMax());
+    assertEquals("AGE", numRangeFilter2.getField());
+    assertTrue(numRangeFilter2.includesMin());
+    assertFalse(numRangeFilter2.includesMax());
+  }
 
+  @SuppressWarnings("unchecked")
-	public void testGetFilterDouble() throws Exception {
-		NumericRangeQueryBuilder filterBuilder = new NumericRangeQueryBuilder();
+  public void testGetFilterDouble() throws Exception {
+    NumericRangeQueryBuilder filterBuilder = new NumericRangeQueryBuilder();
 
-		String xml = "<NumericRangeQuery fieldName='AGE' type='doubLe' lowerTerm='-23.21' upperTerm='60000.00023'/>";
-		Document doc = getDocumentFromString(xml);
+    String xml = "<NumericRangeQuery fieldName='AGE' type='doubLe' lowerTerm='-23.21' upperTerm='60000.00023'/>";
+    Document doc = getDocumentFromString(xml);
 
-		Query filter = filterBuilder.getQuery(doc.getDocumentElement());
-		assertTrue(filter instanceof NumericRangeQuery<?>);
+    Query filter = filterBuilder.getQuery(doc.getDocumentElement());
+    assertTrue(filter instanceof NumericRangeQuery<?>);
-		@SuppressWarnings("unchecked")
+
-		NumericRangeQuery<Double> numRangeFilter = (NumericRangeQuery) filter;
-		assertEquals(Double.valueOf(-23.21d), numRangeFilter.getMin());
-		assertEquals(Double.valueOf(60000.00023d), numRangeFilter.getMax());
-		assertEquals("AGE", numRangeFilter.getField());
-		assertTrue(numRangeFilter.includesMin());
-		assertTrue(numRangeFilter.includesMax());
+    NumericRangeQuery<Double> numRangeFilter = (NumericRangeQuery) filter;
+    assertEquals(Double.valueOf(-23.21d), numRangeFilter.getMin());
+    assertEquals(Double.valueOf(60000.00023d), numRangeFilter.getMax());
+    assertEquals("AGE", numRangeFilter.getField());
+    assertTrue(numRangeFilter.includesMin());
+    assertTrue(numRangeFilter.includesMax());
 
-		String xml2 = "<NumericRangeQuery fieldName='AGE' type='doubLe' lowerTerm='-23.21' upperTerm='60000.00023' includeUpper='false'/>";
-		Document doc2 = getDocumentFromString(xml2);
-		Query filter2 = filterBuilder.getQuery(doc2.getDocumentElement());
-		assertTrue(filter2 instanceof NumericRangeQuery<?>);
+    String xml2 = "<NumericRangeQuery fieldName='AGE' type='doubLe' lowerTerm='-23.21' upperTerm='60000.00023' includeUpper='false'/>";
+    Document doc2 = getDocumentFromString(xml2);
+    Query filter2 = filterBuilder.getQuery(doc2.getDocumentElement());
+    assertTrue(filter2 instanceof NumericRangeQuery<?>);
-		@SuppressWarnings("unchecked")
+
-		NumericRangeQuery<Double> numRangeFilter2 = (NumericRangeQuery) filter2;
-		assertEquals(Double.valueOf(-23.21d), numRangeFilter2.getMin());
-		assertEquals(Double.valueOf(60000.00023d), numRangeFilter2.getMax());
-		assertEquals("AGE", numRangeFilter2.getField());
-		assertTrue(numRangeFilter2.includesMin());
-		assertFalse(numRangeFilter2.includesMax());
-	}
+    NumericRangeQuery<Double> numRangeFilter2 = (NumericRangeQuery) filter2;
+    assertEquals(Double.valueOf(-23.21d), numRangeFilter2.getMin());
+    assertEquals(Double.valueOf(60000.00023d), numRangeFilter2.getMax());
+    assertEquals("AGE", numRangeFilter2.getField());
+    assertTrue(numRangeFilter2.includesMin());
+    assertFalse(numRangeFilter2.includesMax());
+  }
 
+  @SuppressWarnings("unchecked")
-	public void testGetFilterFloat() throws Exception {
-		NumericRangeQueryBuilder filterBuilder = new NumericRangeQueryBuilder();
+  public void testGetFilterFloat() throws Exception {
+    NumericRangeQueryBuilder filterBuilder = new NumericRangeQueryBuilder();
 
-		String xml = "<NumericRangeQuery fieldName='AGE' type='FLOAT' lowerTerm='-2.321432' upperTerm='32432.23'/>";
-		Document doc = getDocumentFromString(xml);
+    String xml = "<NumericRangeQuery fieldName='AGE' type='FLOAT' lowerTerm='-2.321432' upperTerm='32432.23'/>";
+    Document doc = getDocumentFromString(xml);
 
-		Query filter = filterBuilder.getQuery(doc.getDocumentElement());
-		assertTrue(filter instanceof NumericRangeQuery<?>);
+    Query filter = filterBuilder.getQuery(doc.getDocumentElement());
+    assertTrue(filter instanceof NumericRangeQuery<?>);
-		@SuppressWarnings("unchecked")
+
-		NumericRangeQuery<Float> numRangeFilter = (NumericRangeQuery) filter;
-		assertEquals(Float.valueOf(-2.321432f), numRangeFilter.getMin());
-		assertEquals(Float.valueOf(32432.23f), numRangeFilter.getMax());
-		assertEquals("AGE", numRangeFilter.getField());
-		assertTrue(numRangeFilter.includesMin());
-		assertTrue(numRangeFilter.includesMax());
+    NumericRangeQuery<Float> numRangeFilter = (NumericRangeQuery) filter;
+    assertEquals(Float.valueOf(-2.321432f), numRangeFilter.getMin());
+    assertEquals(Float.valueOf(32432.23f), numRangeFilter.getMax());
+    assertEquals("AGE", numRangeFilter.getField());
+    assertTrue(numRangeFilter.includesMin());
+    assertTrue(numRangeFilter.includesMax());
 
-		String xml2 = "<NumericRangeQuery fieldName='AGE' type='FLOAT' lowerTerm='-2.321432' upperTerm='32432.23' includeUpper='false' precisionStep='2' />";
-		Document doc2 = getDocumentFromString(xml2);
+    String xml2 = "<NumericRangeQuery fieldName='AGE' type='FLOAT' lowerTerm='-2.321432' upperTerm='32432.23' includeUpper='false' precisionStep='2' />";
+    Document doc2 = getDocumentFromString(xml2);
 
-		Query filter2 = filterBuilder.getQuery(doc2.getDocumentElement());
-		assertTrue(filter2 instanceof NumericRangeQuery<?>);
+    Query filter2 = filterBuilder.getQuery(doc2.getDocumentElement());
+    assertTrue(filter2 instanceof NumericRangeQuery<?>);
-		@SuppressWarnings("unchecked")
+
-		NumericRangeQuery<Float> numRangeFilter2 = (NumericRangeQuery) filter2;
-		assertEquals(Float.valueOf(-2.321432f), numRangeFilter2.getMin());
-		assertEquals(Float.valueOf(32432.23f), numRangeFilter2.getMax());
-		assertEquals("AGE", numRangeFilter2.getField());
-		assertTrue(numRangeFilter2.includesMin());
-		assertFalse(numRangeFilter2.includesMax());
-	}
+    NumericRangeQuery<Float> numRangeFilter2 = (NumericRangeQuery) filter2;
+    assertEquals(Float.valueOf(-2.321432f), numRangeFilter2.getMin());
+    assertEquals(Float.valueOf(32432.23f), numRangeFilter2.getMax());
+    assertEquals("AGE", numRangeFilter2.getField());
+    assertTrue(numRangeFilter2.includesMin());
+    assertFalse(numRangeFilter2.includesMax());
+  }
 
-	private static Document getDocumentFromString(String str)
-			throws SAXException, IOException, ParserConfigurationException {
-		InputStream is = new ByteArrayInputStream(str.getBytes());
-		DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
-		factory.setNamespaceAware(true);
-		DocumentBuilder builder = factory.newDocumentBuilder();
-		Document doc = builder.parse(is);
-		is.close();
-		return doc;
-	}
+  private static Document getDocumentFromString(String str)
+      throws SAXException, IOException, ParserConfigurationException {
+    InputStream is = new ByteArrayInputStream(str.getBytes());
+    DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
+    factory.setNamespaceAware(true);
+    DocumentBuilder builder = factory.newDocumentBuilder();
+    Document doc = builder.parse(is);
+    is.close();
+    return doc;
+  }
 
 }
Index: lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/SpanNotBuilder.java
===================================================================
--- lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/SpanNotBuilder.java	(revision 811070)
+++ lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/SpanNotBuilder.java	Thu Jul 14 17:10:15 NZST 2011
@@ -23,36 +23,34 @@
  */
 
 /**
- * 
+ *
  */
-public class SpanNotBuilder extends SpanBuilderBase
-{
+public class SpanNotBuilder extends SpanBuilderBase {
-    
+
-    SpanQueryBuilder factory;    
+  private final SpanQueryBuilder factory;
 
-    /**
-     * @param factory
-     */
+  /**
+   * @param factory
+   */
-    public SpanNotBuilder(SpanQueryBuilder factory)
-    {
+  public SpanNotBuilder(SpanQueryBuilder factory) {
-        super();
-        this.factory = factory;
-    }
+    super();
+    this.factory = factory;
+  }
-	public SpanQuery getSpanQuery(Element e) throws ParserException
-	{
+
+  public SpanQuery getSpanQuery(Element e) throws ParserException {
-  	    Element includeElem=DOMUtils.getChildByTagOrFail(e,"Include");
+    Element includeElem = DOMUtils.getChildByTagOrFail(e, "Include");
-        includeElem=DOMUtils.getFirstChildOrFail(includeElem);
+    includeElem = DOMUtils.getFirstChildOrFail(includeElem);
 
-  	    Element excludeElem=DOMUtils.getChildByTagOrFail(e,"Exclude");
+    Element excludeElem = DOMUtils.getChildByTagOrFail(e, "Exclude");
-        excludeElem=DOMUtils.getFirstChildOrFail(excludeElem);
+    excludeElem = DOMUtils.getFirstChildOrFail(excludeElem);
 
-  	    SpanQuery include=factory.getSpanQuery(includeElem);
+    SpanQuery include = factory.getSpanQuery(includeElem);
-  	    SpanQuery exclude=factory.getSpanQuery(excludeElem);
+    SpanQuery exclude = factory.getSpanQuery(excludeElem);
-	    
+
-		SpanNotQuery snq = new SpanNotQuery(include,exclude);
+    SpanNotQuery snq = new SpanNotQuery(include, exclude);
-		
+
-		snq.setBoost(DOMUtils.getAttribute(e,"boost",1.0f));
+    snq.setBoost(DOMUtils.getAttribute(e, "boost", 1.0f));
-		return snq;
-	}
+    return snq;
+  }
 
 }
Index: lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/SpanQueryBuilderFactory.java
===================================================================
--- lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/SpanQueryBuilderFactory.java	(revision 834414)
+++ lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/SpanQueryBuilderFactory.java	Thu Jul 14 17:11:03 NZST 2011
@@ -1,11 +1,12 @@
 package org.apache.lucene.xmlparser.builders;
 
-import java.util.HashMap;
-
 import org.apache.lucene.search.Query;
 import org.apache.lucene.search.spans.SpanQuery;
 import org.apache.lucene.xmlparser.ParserException;
 import org.w3c.dom.Element;
+
+import java.util.HashMap;
+import java.util.Map;
 /**
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -24,27 +25,26 @@
  */
 
 /**
- * 
+ *
  */
 public class SpanQueryBuilderFactory implements SpanQueryBuilder {
 
-	HashMap<String,SpanQueryBuilder> builders=new HashMap<String,SpanQueryBuilder>();
+  private final Map<String, SpanQueryBuilder> builders = new HashMap<String, SpanQueryBuilder>();
-	
-	public Query getQuery(Element e) throws ParserException {
-		return getSpanQuery(e);
-	}
+
+  public Query getQuery(Element e) throws ParserException {
+    return getSpanQuery(e);
+  }
-	public void addBuilder(String nodeName,SpanQueryBuilder builder)
-	{
+
+  public void addBuilder(String nodeName, SpanQueryBuilder builder) {
-		builders.put(nodeName,builder);
+    builders.put(nodeName, builder);
-	}
+  }
-	public SpanQuery getSpanQuery(Element e) throws ParserException
-	{
+
+  public SpanQuery getSpanQuery(Element e) throws ParserException {
-		SpanQueryBuilder builder= builders.get(e.getNodeName());
+    SpanQueryBuilder builder = builders.get(e.getNodeName());
-		if(builder==null)
-		{
+    if (builder == null) {
-			throw new ParserException("No SpanQueryObjectBuilder defined for node "+e.getNodeName()); 
+      throw new ParserException("No SpanQueryObjectBuilder defined for node " + e.getNodeName());
-		}
-		return builder.getSpanQuery(e); 
-	}
+    }
+    return builder.getSpanQuery(e);
+  }
 
 }
Index: lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/FilteredQueryBuilder.java
===================================================================
--- lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/FilteredQueryBuilder.java	(revision 811070)
+++ lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/FilteredQueryBuilder.java	Thu Jul 14 17:03:15 NZST 2011
@@ -30,35 +30,34 @@
  */
 
 /**
- * 
+ *
  */
 public class FilteredQueryBuilder implements QueryBuilder {
-	
+
-	private FilterBuilder filterFactory;
-	private QueryBuilder queryFactory;
+  private final FilterBuilder filterFactory;
+  private final QueryBuilder queryFactory;
 
-	public FilteredQueryBuilder(FilterBuilder filterFactory, QueryBuilder queryFactory)
-	{
+  public FilteredQueryBuilder(FilterBuilder filterFactory, QueryBuilder queryFactory) {
-		this.filterFactory=filterFactory;
+    this.filterFactory = filterFactory;
-		this.queryFactory=queryFactory;
+    this.queryFactory = queryFactory;
-		
-	}
+
+  }
 
-	/* (non-Javadoc)
-	 * @see org.apache.lucene.xmlparser.QueryObjectBuilder#process(org.w3c.dom.Element)
-	 */
-	public Query getQuery(Element e) throws ParserException {	
+  /* (non-Javadoc)
+    * @see org.apache.lucene.xmlparser.QueryObjectBuilder#process(org.w3c.dom.Element)
+    */
+  public Query getQuery(Element e) throws ParserException {
- 	    Element filterElement=DOMUtils.getChildByTagOrFail(e,"Filter");
+    Element filterElement = DOMUtils.getChildByTagOrFail(e, "Filter");
- 	    filterElement=DOMUtils.getFirstChildOrFail(filterElement);
+    filterElement = DOMUtils.getFirstChildOrFail(filterElement);
- 	    Filter f=filterFactory.getFilter(filterElement);
+    Filter f = filterFactory.getFilter(filterElement);
- 
+
- 	    Element queryElement=DOMUtils.getChildByTagOrFail(e,"Query");
+    Element queryElement = DOMUtils.getChildByTagOrFail(e, "Query");
- 	    queryElement=DOMUtils.getFirstChildOrFail(queryElement);
+    queryElement = DOMUtils.getFirstChildOrFail(queryElement);
- 	    Query q=queryFactory.getQuery(queryElement);
+    Query q = queryFactory.getQuery(queryElement);
- 	    
+
- 	    FilteredQuery fq = new FilteredQuery(q,f);
+    FilteredQuery fq = new FilteredQuery(q, f);
- 	    fq.setBoost(DOMUtils.getAttribute(e,"boost",1.0f));
+    fq.setBoost(DOMUtils.getAttribute(e, "boost", 1.0f));
- 	    return fq;		
-	}
+    return fq;
+  }
 
 }
Index: lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/SpanOrTermsBuilder.java
===================================================================
--- lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/SpanOrTermsBuilder.java	(revision 1102817)
+++ lucene/contrib/xml-query-parser/src/java/org/apache/lucene/xmlparser/builders/SpanOrTermsBuilder.java	Thu Jul 14 17:10:15 NZST 2011
@@ -1,9 +1,5 @@
 package org.apache.lucene.xmlparser.builders;
 
-import java.io.IOException;
-import java.io.StringReader;
-import java.util.ArrayList;
-
 import org.apache.lucene.analysis.Analyzer;
 import org.apache.lucene.analysis.TokenStream;
 import org.apache.lucene.analysis.tokenattributes.TermToBytesRefAttribute;
@@ -15,6 +11,11 @@
 import org.apache.lucene.xmlparser.DOMUtils;
 import org.apache.lucene.xmlparser.ParserException;
 import org.w3c.dom.Element;
+
+import java.io.IOException;
+import java.io.StringReader;
+import java.util.ArrayList;
+import java.util.List;
 /**
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -33,48 +34,44 @@
  */
 
 /**
- * 
+ *
  */
-public class SpanOrTermsBuilder extends SpanBuilderBase
-{
-    Analyzer analyzer;
+public class SpanOrTermsBuilder extends SpanBuilderBase {
-    
+
+  private final Analyzer analyzer;
-    
-    /**
-     * @param analyzer
-     */
+
+  /**
+   * @param analyzer
+   */
-    public SpanOrTermsBuilder(Analyzer analyzer)
-    {
+  public SpanOrTermsBuilder(Analyzer analyzer) {
-        super();
-        this.analyzer = analyzer;
-    }
+    super();
+    this.analyzer = analyzer;
+  }
-	public SpanQuery getSpanQuery(Element e) throws ParserException
-	{
+
+  public SpanQuery getSpanQuery(Element e) throws ParserException {
- 		String fieldName=DOMUtils.getAttributeWithInheritanceOrFail(e,"fieldName");
+    String fieldName = DOMUtils.getAttributeWithInheritanceOrFail(e, "fieldName");
- 		String value=DOMUtils.getNonBlankTextOrFail(e);
+    String value = DOMUtils.getNonBlankTextOrFail(e);
-		
+
-		try
-		{
-			ArrayList<SpanQuery> clausesList=new ArrayList<SpanQuery>();
+    try {
+      List<SpanQuery> clausesList = new ArrayList<SpanQuery>();
-			TokenStream ts=analyzer.reusableTokenStream(fieldName,new StringReader(value));
+      TokenStream ts = analyzer.reusableTokenStream(fieldName, new StringReader(value));
-			TermToBytesRefAttribute termAtt = ts.addAttribute(TermToBytesRefAttribute.class);
+      TermToBytesRefAttribute termAtt = ts.addAttribute(TermToBytesRefAttribute.class);
       BytesRef bytes = termAtt.getBytesRef();
       ts.reset();
-	    while (ts.incrementToken()) {
-	        termAtt.fillBytesRef();
+      while (ts.incrementToken()) {
+        termAtt.fillBytesRef();
-			    SpanTermQuery stq=new SpanTermQuery(new Term(fieldName, new BytesRef(bytes)));
+        SpanTermQuery stq = new SpanTermQuery(new Term(fieldName, new BytesRef(bytes)));
-			    clausesList.add(stq);
-			}
-	    ts.end();
-	    ts.close();
+        clausesList.add(stq);
+      }
+      ts.end();
+      ts.close();
-			SpanOrQuery soq=new SpanOrQuery(clausesList.toArray(new SpanQuery[clausesList.size()]));
+      SpanOrQuery soq = new SpanOrQuery(clausesList.toArray(new SpanQuery[clausesList.size()]));
-			soq.setBoost(DOMUtils.getAttribute(e,"boost",1.0f));
+      soq.setBoost(DOMUtils.getAttribute(e, "boost", 1.0f));
-			return soq;
-		}
+      return soq;
+    }
-		catch(IOException ioe)
-		{
+    catch (IOException ioe) {
-		    throw new ParserException("IOException parsing value:"+value);
+      throw new ParserException("IOException parsing value:" + value);
-		}
-	}
+    }
+  }
 
 }
