1 10 package org.mmbase.storage.search.implementation; 11 12 import java.util.*; 13 import org.mmbase.bridge.Field; 14 import org.mmbase.storage.search.*; 15 import org.mmbase.storage.search.StringSearchConstraint; 16 17 24 public class BasicStringSearchConstraint extends BasicFieldConstraint implements StringSearchConstraint { 25 26 27 private int searchType = 0; 28 29 30 private int matchType = 0; 31 32 33 private Map parameters = new HashMap(3); 34 35 36 private List searchTerms = null; 37 38 49 public BasicStringSearchConstraint(StepField field, int searchType, 50 int matchType, List searchTerms) { 51 this(field, searchType, matchType); 52 setSearchTerms(searchTerms); 53 } 54 55 67 public BasicStringSearchConstraint(StepField field, int searchType, 68 int matchType, String searchTerms) { 69 this(field, searchType, matchType); 70 setSearchTerms(searchTerms); 71 } 72 73 84 private BasicStringSearchConstraint(StepField field, int searchType, 85 int matchType) { 86 super(field); 87 if (field.getType() != Field.TYPE_STRING 88 && field.getType() != Field.TYPE_XML) { 89 throw new IllegalArgumentException ( 90 "StringSearchConstraint not allowed for this field type: " 91 + getField().getType()); 92 } 93 setSearchType(searchType); 94 setMatchType(matchType); 95 } 96 97 105 public BasicStringSearchConstraint setMatchType(int matchType) { 106 if (matchType != StringSearchConstraint.MATCH_TYPE_LITERAL 107 && matchType != StringSearchConstraint.MATCH_TYPE_FUZZY 108 && matchType != StringSearchConstraint.MATCH_TYPE_SYNONYM) { 109 throw new IllegalArgumentException ( 110 "Invalid match type value: " + matchType); 111 } 112 this.matchType = matchType; 113 if (matchType != StringSearchConstraint.MATCH_TYPE_FUZZY) { 114 parameters.remove(StringSearchConstraint.PARAM_FUZZINESS); 115 } 116 return this; 117 } 118 119 127 public BasicStringSearchConstraint setSearchType(int searchType) { 128 if (searchType != StringSearchConstraint.SEARCH_TYPE_WORD_ORIENTED 129 && searchType != StringSearchConstraint.SEARCH_TYPE_PHRASE_ORIENTED 130 && searchType != StringSearchConstraint.SEARCH_TYPE_PROXIMITY_ORIENTED) { 131 throw new IllegalArgumentException ( 132 "Invalid search type value: " + searchType); 133 } 134 this.searchType = searchType; 135 if (searchType != StringSearchConstraint.SEARCH_TYPE_PROXIMITY_ORIENTED) { 136 parameters.remove(StringSearchConstraint.PARAM_PROXIMITY_LIMIT); 137 } 138 return this; 139 } 140 141 148 public BasicStringSearchConstraint addSearchTerm(String searchTerm) { 149 if (searchTerm.trim().length() == 0) { 150 throw new IllegalArgumentException ( 151 "Invalid search term value: \"" + searchTerm + "\""); 152 } 153 searchTerms.add(searchTerm); 154 return this; 155 } 156 157 164 public BasicStringSearchConstraint setSearchTerms(List searchTerms) { 165 if (searchTerms.size() == 0) { 166 throw new IllegalArgumentException ( 167 "Invalid search terms value: " + searchTerms); 168 } 169 List newSearchTerms = new ArrayList(); 170 Iterator iSearchTerms = searchTerms.iterator(); 171 while (iSearchTerms.hasNext()) { 172 Object searchTerm = iSearchTerms.next(); 173 if (!(searchTerm instanceof String )) { 174 throw new IllegalArgumentException ( 175 "Invalid search term value: " + searchTerm); 176 } 177 newSearchTerms.add(searchTerm); 178 } 179 this.searchTerms = newSearchTerms; 180 return this; 181 } 182 183 191 public BasicStringSearchConstraint setSearchTerms(String searchTerms) { 192 if (searchTerms.trim().length() == 0) { 193 throw new IllegalArgumentException ( 194 "Invalid search terms value: \"" + searchTerms + "\""); 195 } 196 List newSearchTerms = new ArrayList(); 197 StringTokenizer st = new StringTokenizer(searchTerms); 198 while (st.hasMoreTokens()) { 199 newSearchTerms.add(st.nextToken()); 200 } 201 this.searchTerms = newSearchTerms; 202 return this; 203 } 204 205 215 public BasicStringSearchConstraint setParameter(String name, Object value) { 216 if (name.equals(StringSearchConstraint.PARAM_FUZZINESS) 217 && matchType == StringSearchConstraint.MATCH_TYPE_FUZZY) { 218 if (!(value instanceof Float )) { 219 throw new IllegalArgumentException ( 220 "Invalid type for parameter \"" + name + "\": " 221 + value.getClass().getName()); 222 } 223 float floatValue = ((Float ) value).floatValue(); 224 if (floatValue < 0 || floatValue > 1) { 225 throw new IllegalArgumentException ( 226 "Invalid fuzziness value: " + floatValue); 227 } 228 } else if (name.equals(StringSearchConstraint.PARAM_PROXIMITY_LIMIT) 229 && searchType == StringSearchConstraint.SEARCH_TYPE_PROXIMITY_ORIENTED) { 230 if (!(value instanceof Integer )) { 231 throw new IllegalArgumentException ( 232 "Invalid type for parameter \"" + name + "\": " 233 + value.getClass().getName()); 234 } 235 int intValue = ((Integer ) value).intValue(); 236 if (intValue < 1) { 237 throw new IllegalArgumentException ( 238 "Invalid proximity limit value: " + intValue); 239 } 240 } else { 241 throw new IllegalArgumentException ( 242 "Invalid parameter name: \"" + name + "\""); 243 } 244 parameters.put(name, value); 245 return this; 246 } 247 248 public Map getParameters() { 250 return Collections.unmodifiableMap(parameters); 251 } 252 253 public int getMatchType() { 255 return matchType; 256 } 257 258 261 public String getMatchTypeDescription() { 262 try { 263 return StringSearchConstraint.MATCH_TYPE_DESCRIPTIONS[matchType]; 264 } catch (IndexOutOfBoundsException ioobe) { 265 return null; 266 } 267 } 268 269 public int getSearchType() { 271 return searchType; 272 } 273 274 277 public String getSearchTypeDescription() { 278 try { 279 return StringSearchConstraint.SEARCH_TYPE_DESCRIPTIONS[searchType]; 280 } catch (IndexOutOfBoundsException ioobe) { 281 return null; 282 } 283 } 284 285 public List getSearchTerms() { 287 return Collections.unmodifiableList(searchTerms); 288 } 289 290 public int getBasicSupportLevel() { 292 return SearchQueryHandler.SUPPORT_NONE; 294 } 295 296 public boolean equals(Object obj) { 298 if (obj != null && obj.getClass() == getClass()) { 300 BasicStringSearchConstraint constraint = (BasicStringSearchConstraint) obj; 301 return isInverse() == constraint.isInverse() 302 && isCaseSensitive() == constraint.isCaseSensitive() 303 && getField().getFieldName().equals(constraint.getField().getFieldName()) 304 && getField().getStep().getAlias().equals( 305 constraint.getField().getStep().getAlias()) 306 && searchType == constraint.getSearchType() 307 && matchType == constraint.getMatchType() 308 && parameters.equals(constraint.parameters) 309 && searchTerms.equals(constraint.searchTerms); 310 } else { 311 return false; 312 } 313 } 314 315 public int hashCode() { 317 return super.hashCode() 318 + 117 * searchType 319 + 127 * matchType 320 + 131 * parameters.hashCode() 321 + 137 + searchTerms.hashCode(); 322 } 323 324 public String toString() { 326 StringBuffer sb = new StringBuffer ("StringSearchConstraint(inverse:"). 327 append(isInverse()). 328 append("field:").append(getFieldName()). 329 append(", casesensitive:").append(isCaseSensitive()). 330 append(", searchtype:").append(getSearchTypeDescription()). 331 append(", matchtype:").append(getMatchTypeDescription()). 332 append(", parameters:").append(parameters). 333 append(", searchterms:").append(searchTerms). 334 append(")"); 335 return sb.toString(); 336 } 337 } 338 | Popular Tags |