/*

  * Copyright 2001,2004 The Apache Software Foundation.

  * 

  * Licensed 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

  * 

  *      http://www.apache.org/licenses/LICENSE-2.0

  * 

  * 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.

  * See the License for the specific language governing permissions and

  * limitations under the License.

  */

 package org.apache.commons.scaffold.lucene;

 import java.io.IOException;

 import org.apache.commons.scaffold.lang.ParameterException;

 import org.apache.commons.scaffold.lang.ResourceException;

 import org.apache.lucene.analysis.Analyzer;

 import org.apache.lucene.analysis.StopAnalyzer;

 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;

 /**

  * Search engine methods for Lucene.

  *

  * @author Ted Husted

  * @version $Revision: 155464 $ $Date: 2005-02-26 13:26:54 +0000 (Sat, 26 Feb 2005) $

  * @todo Make singleton instead of static

  */

 public final class Engine {

     /**

      * Default path for index ["/var/lucene/scaffold"].

      * Use the <code>setIndexPath</code> method on startup

      * to change.

      * Each application needs its own index path.

      */

     private static String indexPath;

     /**

      * Return path for index.

      */

     public static String getIndexPath() {

         return indexPath;

     }

     /**

      * Set path for index.

      * MUST be set at startup before using other methods.

      */

     public static void init(String _indexPath) {

         indexPath = _indexPath;

     }

     /**

      * Performance optimization to ensure JVM doesn't

      * create a new empty string whenever blankNull

      * needs one.

      */

     private static final String BLANK_STRING = "";

     /**

      * Convenience method to use an empty string in place

      * of a null for indexing.

      *

      * @param string The string to test for null

      * @return A blank String [BLANK_STRING] if string is null

      */

     public static final String blankNull(String string) {

         if (string==null) return BLANK_STRING;

         else return string;

     }

     /**

      * Return default analyzer for application

      * A non-English site should use a different analyzer

      *

      * @return The default analyzer

      * @exception Throws ResourceException on IO error

      */

     public static final Analyzer getAnalyzer() {

         return new StopAnalyzer();

     }

     /**

      * Return default searcher for application.

      *

      * @exception Throws ResourceException on IO error

      * @return default searcher

      */

     public static final Searcher getSearcher()

             throws ResourceException {

         try {

             return new IndexSearcher(getIndexPath());

         }

         catch (IOException e) {

             throw new ResourceException(e);

         }

     } // end getSearcher()

     /**

      * Return default writer for application.

      *

      * @param Set to true to create a new index; usually false.

      * @return default writer

      * @exception Throws ResourceException on IO error

      */

     public static final IndexWriter getIndexWriter(boolean create)

         throws ResourceException {

         try {

             return (new IndexWriter(getIndexPath(),

                 getAnalyzer(),create));

         }

         catch (IOException e) {

             throw new ResourceException(e);

         }

     } // end getIndexWriter()

     /**

      * Return default reader for application.

      *

      * @return default reader

      * @exception Throws ResourceException on IO error

      */

     public static final IndexReader getIndexReader()

         throws ResourceException {

         try {

             return (IndexReader.open(getIndexPath()));

         }

         catch (IOException e) {

             throw new ResourceException(e);

         }

     } // end getIndexReader()

     /**

      * Return hits for model using default searcher.

      *

      * @return hits for model

      * @param query The query we are processing

      */

     public static final Hits getHits(Query query)

         throws ResourceException {

         try {

             return getSearcher().search(query);

         }

         catch (IOException e) {

             throw new ResourceException(e);

         }

     } // end getHits()

     /**

      * Return hits for value and field

      *

      * @param value The term to match ("Smith")

      * @param field The field to patch ("name")

      * @return hits for model

      */

     public static final Query getQuery(

             String value,

             String field) throws ParameterException {

         try {

             return QueryParser.parse(value,field, getAnalyzer());

         }

         catch (ParseException e) {

             throw new ParameterException(e);

         }

     } // end getQuery()

     /**

      * Object for synchronizing deletions to index

      */

     private static final Object INDEX_LOCK = new Object();

     /**

      * Delete record matching term from default index.

      * Access to the index is synchronized.

      *

      * @param term The term matching the entry to delete

      * @exception Throws ResourceException on IO error

      */

     public static final int deleteTerm(Term term)

         throws ResourceException {

         int result = 0;

         synchronized (INDEX_LOCK) {

             IndexReader reader = null;

             try {

                 reader = getIndexReader();

                 result = reader.delete(term);

             }

             catch (IOException e) {

                 throw new ResourceException(e);

             }

             finally {

                 try {

                     if (reader!=null) reader.close();

                 }

                 catch (IOException e) {

                 // do nothing

                 }

             }

         }

         return result;

     } // end deleteTerm()

 } // end Engine