source: trunk/gsdl3/src/java/org/greenstone/gsdl3/service/GS2LuceneSearch.java@ 13270

/*
 *    GS2LuceneSearch.java
 *    Copyright (C) 2006 New Zealand Digital Library, http://www.nzdl.org
 *
 *    This program is free software; you can redistribute it and/or modify
 *   the Free Software Foundation; either version 2 of the License, or
 *    (at your option) any later version.
 *
 *    This program is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU General Public License for more details.
 *
 *    You should have received a copy of the GNU General Public License
 *    along with this program; if not, write to the Free Software
 *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

package org.greenstone.gsdl3.service;

// Greenstone classes
import org.greenstone.gsdl3.util.*;

// XML classes
import org.w3c.dom.Element; 
import org.w3c.dom.NodeList;

// java classes
import java.util.ArrayList;
import java.util.HashMap;

// Logging
import org.apache.log4j.Logger;

public class GS2LuceneSearch
    extends AbstractGS2FieldSearch
{
    
    // TODO: lucene query object
    
    static Logger logger = Logger.getLogger(org.greenstone.gsdl3.service.GS2LuceneSearch.class.getName());

    public GS2LuceneSearch()
    {
    // TODO: create new query object

    // Lucene uses double operators, not single
    AND_OPERATOR = "&&";
    OR_OPERATOR = "||";

    }

    public void cleanUp() {
    super.cleanUp();
    // TODO: clean up query object
    }

        /** configure this service */
    public boolean configure(Element info, Element extra_info)
    {
    if (!super.configure(info, extra_info)){
        return false;
    }
    
    // Lucene doesn't do case folding or stemming or accent folding at the 
    // moment
    does_case = false;
    does_stem = false;
    does_accent = false;
    
    // TODO: configure the query object based on info from config file

    return true;
    }

    /** add in the lucene specific params to TextQuery */
    protected void addCustomQueryParams(Element param_list, String lang) 
    {
    super.addCustomQueryParams(param_list, lang);
    /** lucenes rank param is based on fields, not ranked/not */
    createParameter(RANK_PARAM, param_list, lang);
    }

    /** create a param and add to the list */
    /** we override this to do a special rank param */
    protected void createParameter(String name, Element param_list, String lang) 
    {
    Element param = null;
    if (name.equals(RANK_PARAM)) {
        // get the fields
        ArrayList fields = new ArrayList();
        fields.add("rank");
        ArrayList field_names = new ArrayList();
        field_names.add(getTextString("param.sortBy.rank", lang)); 
        getSortByIndexData(fields, field_names, lang);
        
        param = GSXML.createParameterDescription2(this.doc, name, getTextString("param."+name, lang), GSXML.PARAM_TYPE_ENUM_SINGLE, (String)fields.get(0), fields, field_names );
    }
    if (param != null) {
        param_list.appendChild(param);
    } else {
        super.createParameter(name, param_list, lang);
    }
    }

    protected void getSortByIndexData(ArrayList index_ids, ArrayList index_names, String lang){
    // the field list -  read from config file
    Element field_list = (Element)GSXML.getChildByTagName(this.config_info, GSXML.FIELD_ELEM+GSXML.LIST_MODIFIER);
    NodeList fields = field_list.getElementsByTagName(GSXML.FIELD_ELEM);
    for (int i=0; i< fields.getLength();i++) {
        String shortname = ((Element)fields.item(i)).getAttribute(GSXML.SHORTNAME_ATT);
        String name = ((Element)fields.item(i)).getAttribute(GSXML.NAME_ATT);
        if (name.equals("")) {
        // no name, ignore
        continue;
        }
        // TODO change field so that name is the id, and full metadata name is somthing else
        if (shortname.equals("")) {
        shortname = name;
        }
        if (shortname.equals("ZZ")) {
        // ZZ is a fake index
        continue;
        }
        index_ids.add("by"+shortname);
        // should these be changed to a text element based on lang?
        // or is the name of a metadata element eg dc:Title its 
        // name in all langs
        index_names.add(name);
    }
    }

    /** methods to handle actually doing the query */
    /** do any initialisation of the query object */
    protected boolean setUpQueryer(HashMap params) {
    // TODO
    return true;
    }
    /** do the query */
    protected Object runQuery(String query) {
    // TODO
    return null;
    }
    /** get the total number of docs that match */
    protected long numDocsMatched(Object query_result) {
    // TODO
    return 0;
    }
    /** get the list of doc ids */
    protected String [] getDocIDs(Object query_result) {
    // TODO
    return null;
    }
    /** get the list of doc ranks */
    protected String [] getDocRanks(Object query_result) {
    // TODO
    return null;
    }
    /** add in term info if available */
    protected boolean addTermInfo(Element term_list, HashMap params,
                  Object query_result) {
    // TODO
    return true;
    }

    protected String addFieldInfo(String query, String field) {
    if (field.equals("") || field.equals("ZZ")) {
        return query;
    }
    return field+":("+query+")";
    }

    protected void addQueryElem(StringBuffer s, String q, String f, String c) {

    String combine="";
    if (s.length()>0) {
        combine = " "+c+" ";
    }
    s.append(combine + addFieldInfo(q,f));
    }

    /** Lucene doesn't use these options at the moment */
    protected String addStemOptions(String query, String stem,
                    String casef, String accent) {
    return query;
    }
}