Java tutorial
/******************************************************************************* * Copyright 2009, 2010 Innovation Gate GmbH * * 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 de.innovationgate.wga.common.beans; import java.util.ArrayList; import java.util.Iterator; import java.util.List; import org.dom4j.Element; import de.innovationgate.utils.WGUtils; /** * Represents a lucene rule to index file attachments */ public class LuceneIndexFileRule { private String _filePattern = ""; private int _fileSizeLimit = 0; private boolean _includedInAllContent = false; private float _boost = 1.0F; /** * Wildcard for file name patterns */ public static final String FILEPATTERN_WILDCARD = "*"; /** * File size limit representing that no files are indexed */ public static final int FILESIZELIMIT_INDEX_NONE = 0; /** * File size limit representing that all files are indexed */ public static final int FILESIZELIMIT_INDEX_ALL = -1; /** * get rules from configfile element lucene * @param lucene configfile element * @return list LuceneIndexFileRules */ public static List getRules(Element lucene) { ArrayList list = new ArrayList(); Element rules = lucene.element("filerules"); if (rules == null) { return null; } Iterator rulesIt = rules.elementIterator("filerule"); while (rulesIt.hasNext()) { Element ruleElement = (Element) rulesIt.next(); LuceneIndexFileRule rule = new LuceneIndexFileRule(); rule.setFilePattern(ruleElement.getText()); rule.setFileSizeLimit(Integer.parseInt(ruleElement.attributeValue("filesizelimit"))); if (ruleElement.attributeValue("includedinallcontent").equals("true")) { rule.setIncludedInAllContent(true); } else { rule.setIncludedInAllContent(false); } rule.setBoost(Float.parseFloat(ruleElement.attributeValue("boost", "1.0"))); list.add(rule); } return list; } /** * get rules from configbean list * @return list LuceneIndexItemRules */ public static List<LuceneIndexFileRule> getRules(List<de.innovationgate.wga.config.LuceneIndexFileRule> rules) { ArrayList<LuceneIndexFileRule> list = new ArrayList<LuceneIndexFileRule>(); Iterator<de.innovationgate.wga.config.LuceneIndexFileRule> itemrulesIt = rules.iterator(); while (itemrulesIt.hasNext()) { de.innovationgate.wga.config.LuceneIndexFileRule ruleConf = itemrulesIt.next(); LuceneIndexFileRule rule = new LuceneIndexFileRule(); rule.setFilePattern(ruleConf.getFilePattern()); rule.setFileSizeLimit(ruleConf.getFileSizeLimit()); rule.setIncludedInAllContent(ruleConf.isIncludedInAllContent()); rule.setBoost(ruleConf.getBoost()); list.add(rule); } return list; } /** * Saves rules to lucene configuration in wga.xml * @param lucene The lucene configuration element * @param rules List of {@link LuceneIndexFileRule} objects to be saved */ public static void saveRules(Element lucene, List rules) { Element filerules = WGUtils.getOrCreateElement(lucene, "filerules"); //remove old rules filerules.clearContent(); Iterator itemrulesIt = rules.iterator(); while (itemrulesIt.hasNext()) { LuceneIndexFileRule rule = (LuceneIndexFileRule) itemrulesIt.next(); Element ruleElement = filerules.addElement("filerule"); ruleElement.addAttribute("filesizelimit", new Integer(rule.getFileSizeLimit()).toString()); if (rule.isIncludedInAllContent()) { ruleElement.addAttribute("includedinallcontent", "true"); } else { ruleElement.addAttribute("includedinallcontent", "false"); } ruleElement.addAttribute("boost", Float.toString(rule.getBoost())); ruleElement.addText(rule.getFilePattern()); } } /** * Returns the default rule for newly created databases */ public static LuceneIndexFileRule getDefaultRule() { LuceneIndexFileRule rule = new LuceneIndexFileRule(); rule.setFilePattern(FILEPATTERN_WILDCARD); rule.setFileSizeLimit(FILESIZELIMIT_INDEX_NONE); rule.setIncludedInAllContent(false); rule.setBoost(1.0F); return rule; } /** * adds the default rule to the lucene.itemrules element * @param lucene luceneElement */ public static void addDefaultRule(Element lucene) { Element rules = lucene.element("filerules"); LuceneIndexFileRule rule = getDefaultRule(); Element ruleElement = rules.addElement("filerule"); ruleElement.addAttribute("filesizelimit", new Integer(rule.getFileSizeLimit()).toString()); if (rule.isIncludedInAllContent()) { ruleElement.addAttribute("includedinallcontent", "true"); } else { ruleElement.addAttribute("includedinallcontent", "false"); } ruleElement.addAttribute("boost", Float.toString(rule.getBoost())); ruleElement.addText(rule.getFilePattern()); } /** * Determines if the rule file pattern has a wildcard */ public boolean hasWildcard() { if (this._filePattern == null) { return false; } if (this._filePattern.indexOf(FILEPATTERN_WILDCARD) != -1) { return true; } else { return false; } } /** * Determines if this rule is a default rule that will apply to all files not taken by other rules */ public boolean isDefaultRule() { if (this._filePattern == null) { return false; } if (this._filePattern.trim().equals(FILEPATTERN_WILDCARD)) { return true; } else { return false; } } /** * Returns the file pattern name without eventually trailing text after the wildcard */ public String getFilePatternClearWildcard() { if (this.isDefaultRule()) { return ""; } else { if (_filePattern.length() > 1) { return _filePattern.substring(_filePattern.indexOf(FILEPATTERN_WILDCARD) + 1); } else { return ""; } } } public boolean equals(Object obj) { if (obj instanceof LuceneIndexFileRule) { LuceneIndexFileRule rule = (LuceneIndexFileRule) obj; if ((_filePattern.equals(rule.getFilePattern())) && (_fileSizeLimit == rule.getFileSizeLimit()) && (_includedInAllContent == rule.isIncludedInAllContent()) && (_boost == rule.getBoost())) { return true; } else { return false; } } else { return super.equals(obj); } } /** * Returns the file pattern */ public String getFilePattern() { return _filePattern; } /** * Sets the file pattern. The pattern may end with a wildcard character {@link #FILEPATTERN_WILDCARD}. * @param filePattern */ public void setFilePattern(String filePattern) { _filePattern = filePattern; } /** * Returns the size limit of bytes for indexing files via this rule. * This rule will only apply to files up to this limit. * Note special values {@link #FILESIZELIMIT_INDEX_ALL} and {@link #FILESIZELIMIT_INDEX_NONE} for this setting. */ public int getFileSizeLimit() { return _fileSizeLimit; } /** * Sets the size limit of bytes for indexing files via this rule. * This rule will only apply to files up to this limit. * Note special values {@link #FILESIZELIMIT_INDEX_ALL} and {@link #FILESIZELIMIT_INDEX_NONE} for this setting. * @param fileSizeLimit */ public void setFileSizeLimit(int fileSizeLimit) { _fileSizeLimit = fileSizeLimit; } /** * Returns if the index information of this file should be used for unspecific searches where no item to search is defined. */ public boolean isIncludedInAllContent() { return _includedInAllContent; } /** * Sets if the index information of this file should be used for unspecific searches where no item to search if defined. * If this is false the index information will only be used for searches against item "allattachments" * @param includedInAllContent */ public void setIncludedInAllContent(boolean includedInAllContent) { _includedInAllContent = includedInAllContent; } /** * returns the boost value of this rule */ public float getBoost() { return _boost; } /** * sets the boost value for this rule * @param boost * @throws IllegalArgumentException if boost is <=0 */ public void setBoost(float boost) { if (boost <= 0) { throw new IllegalArgumentException("Boost value must be >0."); } _boost = boost; } }