Author: michiel Date: 2010-06-21 11:54:05 +0200 (Mon, 21 Jun 2010) New Revision: 42627
Modified: mmbase/trunk/bridge/src/main/java/org/mmbase/storage/search/Constraint.java mmbase/trunk/bridge/src/main/java/org/mmbase/storage/search/FieldConstraint.java mmbase/trunk/bridge/src/main/java/org/mmbase/storage/search/FieldValueConstraint.java mmbase/trunk/bridge/src/main/java/org/mmbase/storage/search/implementation/BasicFieldConstraint.java mmbase/trunk/bridge/src/main/java/org/mmbase/storage/search/implementation/BasicFieldValueConstraint.java Log: MMB-1966 Modified: mmbase/trunk/bridge/src/main/java/org/mmbase/storage/search/Constraint.java =================================================================== --- mmbase/trunk/bridge/src/main/java/org/mmbase/storage/search/Constraint.java 2010-06-21 09:52:20 UTC (rev 42626) +++ mmbase/trunk/bridge/src/main/java/org/mmbase/storage/search/Constraint.java 2010-06-21 09:54:05 UTC (rev 42627) @@ -4,7 +4,7 @@ OSI Certified is a certification mark of the Open Source Initiative. The license (Mozilla version 1.0) can be read at the MMBase site. -See http://www.MMBase.org/license +*See http://www.MMBase.org/license */ package org.mmbase.storage.search; Modified: mmbase/trunk/bridge/src/main/java/org/mmbase/storage/search/FieldConstraint.java =================================================================== --- mmbase/trunk/bridge/src/main/java/org/mmbase/storage/search/FieldConstraint.java 2010-06-21 09:52:20 UTC (rev 42626) +++ mmbase/trunk/bridge/src/main/java/org/mmbase/storage/search/FieldConstraint.java 2010-06-21 09:54:05 UTC (rev 42627) @@ -28,4 +28,11 @@ boolean isCaseSensitive(); + + /** + * Determines whether a certain given value would match this constraint. + * @since MMBase-1.9.4 + */ + boolean matches(Object value); + } Modified: mmbase/trunk/bridge/src/main/java/org/mmbase/storage/search/FieldValueConstraint.java =================================================================== --- mmbase/trunk/bridge/src/main/java/org/mmbase/storage/search/FieldValueConstraint.java 2010-06-21 09:52:20 UTC (rev 42626) +++ mmbase/trunk/bridge/src/main/java/org/mmbase/storage/search/FieldValueConstraint.java 2010-06-21 09:54:05 UTC (rev 42627) @@ -20,12 +20,12 @@ */ public interface FieldValueConstraint extends FieldCompareConstraint { /** - * Gets the value to compare with. - * Depending on the field type, the value is of type + * Gets the value to compare with. + * Depending on the field type, the value is of type * <code>String</code> or <code>Number</code>. * <p> - * If the associated field type is of string type, when used in - * combination with the operator <code>LIKE</code>, this may contain the + * If the associated field type is of string type, when used in + * combination with the operator <code>LIKE</code>, this may contain the * following wildcard characters as well: * <ul> * <li>% for any string @@ -35,16 +35,16 @@ Object getValue(); /** - * Returns a string representation of this FieldValueConstraint. - * The string representation has the form - * "FieldValueConstraint(inverse:<:inverse>, field:<field>, + * Returns a string representation of this FieldValueConstraint. + * The string representation has the form + * "FieldValueConstraint(inverse:<:inverse>, field:<field>, * casesensitive:<casesensitive>, operator:<operator>, * value:<value>)" - * where + * where * <ul> * <li><em><inverse></em>is the value returned by * {...@link #isInverse isInverse()} - * <li><em><field></em> is the field alias returned by + * <li><em><field></em> is the field alias returned by * <code>FieldConstraint#getField().getAlias()</code>, or * <code>FieldConstraint#getField().getFieldName()</code> * when the former is <code>null</code>. @@ -61,4 +61,10 @@ @Override String toString(); + + /** + * @since MMBase-1.9.4 + */ + boolean matches(Object value); + } Modified: mmbase/trunk/bridge/src/main/java/org/mmbase/storage/search/implementation/BasicFieldConstraint.java =================================================================== --- mmbase/trunk/bridge/src/main/java/org/mmbase/storage/search/implementation/BasicFieldConstraint.java 2010-06-21 09:52:20 UTC (rev 42626) +++ mmbase/trunk/bridge/src/main/java/org/mmbase/storage/search/implementation/BasicFieldConstraint.java 2010-06-21 09:54:05 UTC (rev 42627) @@ -57,6 +57,11 @@ } @Override + public boolean matches(Object o) { + throw new UnsupportedOperationException(); + } + + @Override public StepField getField() { return field; } Modified: mmbase/trunk/bridge/src/main/java/org/mmbase/storage/search/implementation/BasicFieldValueConstraint.java =================================================================== --- mmbase/trunk/bridge/src/main/java/org/mmbase/storage/search/implementation/BasicFieldValueConstraint.java 2010-06-21 09:52:20 UTC (rev 42626) +++ mmbase/trunk/bridge/src/main/java/org/mmbase/storage/search/implementation/BasicFieldValueConstraint.java 2010-06-21 09:54:05 UTC (rev 42627) @@ -9,8 +9,12 @@ */ package org.mmbase.storage.search.implementation; +import java.util.Date; +import org.mmbase.util.Casting; import org.mmbase.storage.search.*; +import org.mmbase.util.logging.*; + /** * Basic implementation. * The tested operation is equality, unless it is explicitly set. @@ -21,7 +25,8 @@ */ public class BasicFieldValueConstraint extends BasicFieldCompareConstraint implements FieldValueConstraint, java.io.Serializable { - /** The value. */ + private static final Logger log = Logging.getLoggerInstance(BasicFieldValueConstraint.class); + private Object value = null; /** @@ -59,7 +64,118 @@ return value; } + + private boolean floatMatches(double constraintDouble, double doubleTocompare, int operator) { + switch(operator) { + case FieldCompareConstraint.EQUAL: return doubleTocompare == constraintDouble; + case FieldCompareConstraint.GREATER: return doubleTocompare > constraintDouble; + case FieldCompareConstraint.GREATER_EQUAL: return doubleTocompare >= constraintDouble; + case FieldCompareConstraint.LESS: return doubleTocompare < constraintDouble; + case FieldCompareConstraint.LESS_EQUAL: return doubleTocompare <= constraintDouble; + case FieldCompareConstraint.NOT_EQUAL: return doubleTocompare != constraintDouble; + default: + log.warn("operator " + FieldCompareConstraint.OPERATOR_DESCRIPTIONS[operator] + "for any numeric type"); + return true; + + } + } + + private boolean intMatches(long constraintLong, long longToCompare, int operator) { + switch(operator) { + case FieldCompareConstraint.EQUAL: return longToCompare == constraintLong; + case FieldCompareConstraint.GREATER: return longToCompare > constraintLong; + case FieldCompareConstraint.GREATER_EQUAL: return longToCompare >= constraintLong; + case FieldCompareConstraint.LESS: return longToCompare < constraintLong; + case FieldCompareConstraint.LESS_EQUAL: return longToCompare <= constraintLong; + case FieldCompareConstraint.NOT_EQUAL: return longToCompare != constraintLong; + default: + log.warn("operator " + FieldCompareConstraint.OPERATOR_DESCRIPTIONS[operator] + "for any numeric type"); + return true; + } + } + + private boolean stringMatches(String constraintString, String stringToCompare, int operator, boolean isCaseSensitive) { + switch(operator) { + case FieldCompareConstraint.EQUAL: return stringToCompare.equals(constraintString); + // TODO: MM: I think depending on the database configuration the case-sensitivity may be important in the following 4: + case FieldCompareConstraint.GREATER: return stringToCompare.compareTo(constraintString) > 0; + case FieldCompareConstraint.LESS: return stringToCompare.compareTo(constraintString) < 0; + case FieldCompareConstraint.LESS_EQUAL: return stringToCompare.compareTo(constraintString) <= 0; + case FieldCompareConstraint.GREATER_EQUAL: return stringToCompare.compareTo(constraintString) >= 0; + case FieldCompareConstraint.LIKE: return likeMatches(constraintString, stringToCompare, isCaseSensitive); + case FieldCompareConstraint.NOT_EQUAL: return ! stringToCompare.equals(constraintString); + default: + log.warn("operator " + FieldCompareConstraint.OPERATOR_DESCRIPTIONS[operator] + "is not supported for type String"); + return true; + } + } + + private final static String escapeChars=".\\?+*$()[]{}^|&"; + private boolean likeMatches(String constraintString, String stringToCompare, boolean isCaseSensitive){ + if (log.isTraceEnabled()) { + log.trace("** method: likeMatches() stringToCompare: " + stringToCompare + ", constraintString: " + constraintString ); + } + if(isCaseSensitive){ + constraintString = constraintString.toLowerCase(); + stringToCompare = stringToCompare.toLowerCase(); + } + char[] chars = constraintString.toCharArray(); + StringBuffer sb = new StringBuffer(); + + for (char element : chars) { + if(element == '?'){ + sb.append("."); + } else if(element == '%'){ + sb.append(".*"); + } else if(escapeChars.indexOf(element) > -1){ + sb.append("\\"); + sb.append(element); + } else{ + sb.append(element); + } + } + if (log.isDebugEnabled()) { + log.trace("** new pattern: " + sb.toString()); + } + return stringToCompare.matches(sb.toString()); + } + @Override + public boolean matches(Object o) { + boolean res; + if (o == null) { + res = true; + } else { + Class fieldType = getValue().getClass(); + Object compareValue = Casting.toType(fieldType, o); + if (fieldType.equals(Boolean.class)) { + switch(getOperator()) { + case FieldCompareConstraint.EQUAL: res = getValue().equals(compareValue); break; + case FieldCompareConstraint.NOT_EQUAL: res = ! getValue().equals(compareValue); break; + default: + throw new UnsupportedOperationException(); + } + } else if (fieldType.equals(Float.class)) { + res = floatMatches((Float) getValue(), (Float) compareValue, getOperator()); + } else if (fieldType.equals(Double.class)) { + res = floatMatches((Double) getValue(), (Double) compareValue, getOperator()); + } else if (fieldType.equals(Date.class)) { + res = intMatches(((Date) getValue()).getTime(), ((Date) compareValue).getTime(), getOperator()); + } else if (fieldType.equals(Integer.class)) { + res = intMatches((Integer) getValue(), (Integer) compareValue, getOperator()); + } else if (fieldType.equals(Long.class)) { + res = intMatches((Long) getValue(), (Long) compareValue, getOperator()); + } else if (fieldType.equals(String.class) || fieldType.equals(org.w3c.dom.Document.class)) { + res = stringMatches((String) getValue(), (String) compareValue, getOperator(), isCaseSensitive()); + } else { + throw new UnsupportedOperationException(); + } + } + if (isInverse()) res = ! res; + return res; + } + + @Override public boolean equals(Object obj) { // Must be same class (subclasses should override this)! if (obj != null && obj.getClass() == getClass()) { _______________________________________________ Cvs mailing list [email protected] http://lists.mmbase.org/mailman/listinfo/cvs
