/**
* License Agreement for OpenSearchServer
* <p>
* Copyright (C) 2011-2013 Emmanuel Keller / Jaeksoft
* <p>
* http://www.open-search-server.com
* <p>
* This file is part of OpenSearchServer.
* <p>
* OpenSearchServer is free software: you can redistribute it and/or
* modify it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
* <p>
* OpenSearchServer 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.
* <p>
* You should have received a copy of the GNU General Public License
* along with OpenSearchServer.
* If not, see <http://www.gnu.org/licenses/>.
**/
package com.jaeksoft.searchlib.classifier;
import com.jaeksoft.searchlib.Client;
import com.jaeksoft.searchlib.SearchLibException;
import com.jaeksoft.searchlib.analysis.LanguageEnum;
import com.jaeksoft.searchlib.function.expression.SyntaxError;
import com.jaeksoft.searchlib.index.FieldContent;
import com.jaeksoft.searchlib.index.IndexDocument;
import com.jaeksoft.searchlib.query.ParseException;
import com.jaeksoft.searchlib.util.DomUtils;
import com.jaeksoft.searchlib.util.FormatUtils.ThreadSafeDecimalFormat;
import com.jaeksoft.searchlib.util.ReadWriteLock;
import com.jaeksoft.searchlib.util.XPathParser;
import com.jaeksoft.searchlib.util.XmlWriter;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.index.memory.MemoryIndex;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.xml.sax.SAXException;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.stream.StreamSource;
import javax.xml.xpath.XPathExpressionException;
import java.io.File;
import java.io.IOException;
import java.util.List;
import java.util.TreeSet;
public class Classifier implements Comparable<Classifier>, XmlWriter.Interface {
private final static String CLASSIFIER_ITEM_ROOTNODE_NAME = "classifier";
private final static String CLASSIFIER_ITEM_NODE_NAME = "classifierItem";
private final static String CLASSIFIER_ITEM_ROOT_ATTR_NAME = "name";
private final static String CLASSIFIER_ITEM_ROOT_ATTR_FIELD = "field";
private final static String CLASSIFIER_ITEM_ROOT_ATTR_SCOREFIELD = "scoreField";
private final static String CLASSIFIER_ITEM_ROOT_ATTR_ACTIVE = "active";
private final static String CLASSIFIER_ITEM_ROOT_ATTR_METHOD = "method";
private final static String CLASSIFIER_ITEM_DEFAULT_VALUE_NODE = "defaultValue";
private final ReadWriteLock rwl = new ReadWriteLock();
private String name;
private String fieldName;
private String scoreFieldName;
private boolean active;
private String defaultValue;
private TreeSet<ClassifierItem> valueSet;
private ClassifierItem[] valueSetArray;
private ClassificationMethodEnum method;
public Classifier() {
valueSetArray = null;
valueSet = new TreeSet<ClassifierItem>();
name = null;
fieldName = null;
scoreFieldName = null;
active = false;
defaultValue = null;
method = ClassificationMethodEnum.BESTSCORE;
}
public Classifier(Classifier source) {
this();
source.copyTo(this);
}
public void copyTo(Classifier target) {
rwl.r.lock();
try {
target.rwl.w.lock();
try {
target.name = name;
target.fieldName = fieldName;
target.scoreFieldName = scoreFieldName;
target.active = active;
target.method = method;
target.valueSetArray = null;
target.defaultValue = defaultValue;
target.valueSet.clear();
for (ClassifierItem item : valueSet)
target.valueSet.add(new ClassifierItem(item));
target.buildValueSetArray();
} finally {
target.rwl.w.unlock();
}
} finally {
rwl.r.unlock();
}
}
protected Classifier(File file)
throws ParserConfigurationException, SAXException, IOException, XPathExpressionException,
SearchLibException {
this();
if (!file.exists())
return;
Document document = DomUtils.readXml(new StreamSource(file), false);
Node rootNode = DomUtils.getFirstNode(document, CLASSIFIER_ITEM_ROOTNODE_NAME);
if (rootNode == null)
return;
setName(XPathParser.getAttributeString(rootNode, CLASSIFIER_ITEM_ROOT_ATTR_NAME));
setFieldName(XPathParser.getAttributeString(rootNode, CLASSIFIER_ITEM_ROOT_ATTR_FIELD));
setScoreFieldName(XPathParser.getAttributeString(rootNode, CLASSIFIER_ITEM_ROOT_ATTR_SCOREFIELD));
setActive("yes".equalsIgnoreCase(XPathParser.getAttributeString(rootNode, CLASSIFIER_ITEM_ROOT_ATTR_ACTIVE)));
setMethod(ClassificationMethodEnum
.find(XPathParser.getAttributeString(rootNode, CLASSIFIER_ITEM_ROOT_ATTR_METHOD)));
Node defaultValueNode = DomUtils.getFirstNode(rootNode, CLASSIFIER_ITEM_DEFAULT_VALUE_NODE);
if (defaultValueNode != null)
setDefaultValue(defaultValueNode.getTextContent());
List<Node> nodes = DomUtils.getNodes(rootNode, CLASSIFIER_ITEM_NODE_NAME);
if (nodes == null)
return;
for (Node n : nodes)
addNoLock(new ClassifierItem(n));
buildValueSetArray();
}
/**
* @param name
* the name to set
*/
public void setName(String name) {
this.name = name;
}
/**
* @return the name
*/
public String getName() {
return name;
}
public ClassifierItem[] getValueSet() {
rwl.r.lock();
try {
return valueSetArray;
} finally {
rwl.r.unlock();
}
}
public int getValueSetSize() {
rwl.r.lock();
try {
return valueSetArray == null ? 0 : valueSetArray.length;
} finally {
rwl.r.unlock();
}
}
private final void buildValueSetArray() {
valueSetArray = new ClassifierItem[valueSet.size()];
valueSet.toArray(valueSetArray);
}
private final void addNoLock(ClassifierItem item) {
valueSet.add(item);
}
public void add(ClassifierItem item) throws SearchLibException {
rwl.w.lock();
try {
addNoLock(item);
buildValueSetArray();
} finally {
rwl.w.unlock();
}
}
public void replace(ClassifierItem oldItem, ClassifierItem newItem) {
rwl.w.lock();
try {
valueSet.remove(oldItem);
valueSet.add(newItem);
buildValueSetArray();
} finally {
rwl.w.unlock();
}
}
public void remove(ClassifierItem item) {
rwl.w.lock();
try {
valueSet.remove(item);
buildValueSetArray();
} finally {
rwl.w.unlock();
}
}
/**
* @param fieldName
* the fieldName to set
*/
public void setFieldName(String fieldName) {
rwl.w.lock();
try {
this.fieldName = fieldName;
} finally {
rwl.w.unlock();
}
}
/**
* @return the fieldName
*/
public String getFieldName() {
return fieldName;
}
/**
* @param scoreFieldName
* the scoreFieldName to set
*/
public void setScoreFieldName(String scoreFieldName) {
rwl.w.lock();
try {
this.scoreFieldName = scoreFieldName;
} finally {
rwl.w.unlock();
}
}
/**
* @return the scoreFieldName
*/
public String getScoreFieldName() {
return scoreFieldName;
}
/**
* @param active
* the active to set
*/
public void setActive(boolean active) {
this.active = active;
}
/**
* @return the active
*/
public boolean isActive() {
return active;
}
/**
* @param method
* the method to set
*/
public void setMethod(ClassificationMethodEnum method) {
this.method = method;
}
/**
* @return the method
*/
public ClassificationMethodEnum getMethod() {
return method;
}
@Override
public int compareTo(Classifier o) {
return name.compareTo(o.name);
}
@Override
public void writeXml(XmlWriter xmlWriter) throws SAXException {
rwl.r.lock();
try {
xmlWriter.startElement(CLASSIFIER_ITEM_ROOTNODE_NAME, CLASSIFIER_ITEM_ROOT_ATTR_NAME, name,
CLASSIFIER_ITEM_ROOT_ATTR_FIELD, fieldName, CLASSIFIER_ITEM_ROOT_ATTR_SCOREFIELD, scoreFieldName,
CLASSIFIER_ITEM_ROOT_ATTR_ACTIVE, active ? "yes" : "no", CLASSIFIER_ITEM_ROOT_ATTR_METHOD,
method.name());
if (defaultValue != null && defaultValue.length() > 0) {
xmlWriter.startElement(CLASSIFIER_ITEM_DEFAULT_VALUE_NODE);
xmlWriter.textNode(defaultValue);
xmlWriter.endElement();
}
for (ClassifierItem item : valueSet)
item.writeXml(xmlWriter, CLASSIFIER_ITEM_NODE_NAME);
xmlWriter.endElement();
} finally {
rwl.r.unlock();
}
}
private void multivaluedClassification(Client client, IndexDocument document, LanguageEnum lang, MemoryIndex index)
throws ParseException, SearchLibException, SyntaxError, IOException {
boolean setDefaultValue = defaultValue != null && defaultValue.length() > 0;
for (ClassifierItem item : valueSet) {
float score = item.score(client, lang, index);
if (score > 0.0f) {
document.add(fieldName, item.getValue(), item.getBoost());
if (scoreFieldName != null && scoreFieldName.length() > 0)
document.addString(scoreFieldName, Float.toString(score));
setDefaultValue = false;
}
}
if (setDefaultValue)
document.add(fieldName, defaultValue, 1.0F);
}
private final static ThreadSafeDecimalFormat scoreFormat = new ThreadSafeDecimalFormat("0.###########");
private void bestScoreClassification(Client client, IndexDocument document, LanguageEnum lang, MemoryIndex index)
throws ParseException, SearchLibException, SyntaxError, IOException {
ClassifierItem selectedItem = null;
float maxScore = 0;
for (ClassifierItem item : valueSet) {
float score = item.score(client, lang, index);
if (score > maxScore) {
selectedItem = item;
maxScore = score;
}
}
if (selectedItem != null) {
document.add(getFieldName(), selectedItem.getValue(), selectedItem.getBoost());
if (scoreFieldName != null && scoreFieldName.length() > 0) {
document.addString(scoreFieldName, scoreFormat.format(maxScore));
}
} else {
if (defaultValue != null && defaultValue.length() > 0)
document.add(fieldName, defaultValue, 1.0F);
}
}
public void classification(Client client, IndexDocument document)
throws SearchLibException, ParseException, SyntaxError, IOException {
rwl.r.lock();
try {
MemoryIndex index = new MemoryIndex();
LanguageEnum lang = document.getLang();
Analyzer analyzer = client.getSchema().getIndexPerFieldAnalyzer(lang);
for (FieldContent fieldContent : document) {
String fieldName = fieldContent.getField();
String concatValues = fieldContent.getMergedValues(" ");
index.addField(fieldName, concatValues, analyzer);
}
if (method == ClassificationMethodEnum.MULTIVALUED)
multivaluedClassification(client, document, lang, index);
else if (method == ClassificationMethodEnum.BESTSCORE)
bestScoreClassification(client, document, lang, index);
} finally {
rwl.r.unlock();
}
}
/**
* @return the defaultValue
*/
public String getDefaultValue() {
rwl.r.lock();
try {
return defaultValue;
} finally {
rwl.r.unlock();
}
}
/**
* @param defaultValue
* the defaultValue to set
*/
public void setDefaultValue(String defaultValue) {
rwl.w.lock();
try {
this.defaultValue = defaultValue;
} finally {
rwl.w.unlock();
}
}
}