View Javadoc
   package net.sf.flock.lucene;
   
   import java.io.File;
   import java.io.IOException;
   
   import org.apache.lucene.analysis.SimpleAnalyzer;
   import org.apache.lucene.document.Document;
   import org.apache.lucene.index.IndexReader;
   import org.apache.lucene.index.IndexWriter;
  import org.apache.lucene.index.Term;
  import org.apache.lucene.queryParser.ParseException;
  import org.apache.lucene.queryParser.QueryParser;
  import org.apache.lucene.search.Hits;
  import org.apache.lucene.search.IndexSearcher;
  import org.apache.lucene.search.Query;
  import org.apache.lucene.search.Searcher;
  
  public class IndexService {
  
  	private final String indexPath;
  	
  	private IndexWriter writer = null;
  	private Searcher searcher;
  	
  	private boolean dirty = false;	
  	
  	public IndexService(String indexPath) throws IOException {
  		this( indexPath, !new File(indexPath).exists());
  	}
  	
  	public IndexService(String indexPath, boolean create) throws IOException {
  		this.indexPath  = indexPath;
  		if (create) {
  			IndexWriter cw = new IndexWriter(indexPath, null, true);
  			cw.close();
  		}
  		this.searcher = new IndexSearcher(indexPath);
  	}
  
  	private IndexWriter getWriter() throws IOException {
  		if (this.writer==null) {
  			this.writer = new IndexWriter(indexPath, new SimpleAnalyzer(), false);
  			this.writer.mergeFactor = 100;
  			//this.writer.infoStream = System.out; 	
  		} 
  		return this.writer;
  	}
  
  	public synchronized void add(Document document) throws IOException {
  		try {
  			this.getWriter().addDocument(document);
  		} finally {
  			this.dirty=true;
  		}
  	}
  
  	public int delete(String field, String value) throws IOException {
  		return this.delete(new Term(field, value));
  	}
  
  	public synchronized int delete(Term term) throws IOException {
  		IndexReader reader = IndexReader.open(this.indexPath);
  		try {
  			return reader.delete(term);
  		} finally {
  			this.dirty=true;
  			reader.close();
  			// !!! does the writer need to be invalidated at this point?
  		}
  	}
  	
  	public synchronized void update(String matchField, Document document) throws IOException {
  		this.delete(matchField, document.get(matchField));
  		this.add(document);
  	}
  
  	public Hits search(String field, String queryString) throws ParseException, IOException {
  		Query query = QueryParser.parse(queryString, field, new SimpleAnalyzer());
  		return this.search(query);
  	}
  
  	public Hits search(Query query) throws IOException {
  		synchronized (this) {
  			if (this.writer!=null) {
  				// commit pending writes
  				writer.optimize();
  				writer.close();
  				writer=null;	
  			}
  			if (this.dirty) {
  				// recreate reader
  				// !!! this interrupts ongoing searches
  				this.searcher.close();
  				this.searcher = new IndexSearcher(indexPath);
  				dirty = false;
  			}
  		}
  		Hits hits = this.searcher.search(query);
  		return hits;
 	}
 	
 	public synchronized void close() {
 		try {
 			if (this.writer!=null) {
 				this.writer.close();
 			}
 		} catch (IOException e) {
 			e.printStackTrace();
 		} finally {
 			this.writer=null;		
 		}
 		try {
 			this.searcher.close();
 		} catch (IOException e) {
 			e.printStackTrace();
 		} finally {
 			this.searcher=null;		
 		}
 	}
 
 }