Author: michiel
Date: 2010-06-21 11:52:20 +0200 (Mon, 21 Jun 2010)
New Revision: 42626
Modified:
mmbase/branches/MMBase-1_9/core/src/main/java/org/mmbase/storage/search/FieldConstraint.java
mmbase/branches/MMBase-1_9/core/src/main/java/org/mmbase/storage/search/FieldValueConstraint.java
mmbase/branches/MMBase-1_9/core/src/main/java/org/mmbase/storage/search/implementation/BasicFieldConstraint.java
mmbase/branches/MMBase-1_9/core/src/main/java/org/mmbase/storage/search/implementation/BasicFieldValueConstraint.java
Log:
MMB-1966
Modified:
mmbase/branches/MMBase-1_9/core/src/main/java/org/mmbase/storage/search/FieldConstraint.java
===================================================================
---
mmbase/branches/MMBase-1_9/core/src/main/java/org/mmbase/storage/search/FieldConstraint.java
2010-06-21 09:47:28 UTC (rev 42625)
+++
mmbase/branches/MMBase-1_9/core/src/main/java/org/mmbase/storage/search/FieldConstraint.java
2010-06-21 09:52:20 UTC (rev 42626)
@@ -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/branches/MMBase-1_9/core/src/main/java/org/mmbase/storage/search/FieldValueConstraint.java
===================================================================
---
mmbase/branches/MMBase-1_9/core/src/main/java/org/mmbase/storage/search/FieldValueConstraint.java
2010-06-21 09:47:28 UTC (rev 42625)
+++
mmbase/branches/MMBase-1_9/core/src/main/java/org/mmbase/storage/search/FieldValueConstraint.java
2010-06-21 09:52:20 UTC (rev 42626)
@@ -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,5 @@
@Override
String toString();
+
}
Modified:
mmbase/branches/MMBase-1_9/core/src/main/java/org/mmbase/storage/search/implementation/BasicFieldConstraint.java
===================================================================
---
mmbase/branches/MMBase-1_9/core/src/main/java/org/mmbase/storage/search/implementation/BasicFieldConstraint.java
2010-06-21 09:47:28 UTC (rev 42625)
+++
mmbase/branches/MMBase-1_9/core/src/main/java/org/mmbase/storage/search/implementation/BasicFieldConstraint.java
2010-06-21 09:52:20 UTC (rev 42626)
@@ -56,6 +56,11 @@
return this;
}
+ public boolean matches(Object o) {
+ throw new UnsupportedOperationException();
+ }
+
+
// javadoc is inherited
public StepField getField() {
return field;
Modified:
mmbase/branches/MMBase-1_9/core/src/main/java/org/mmbase/storage/search/implementation/BasicFieldValueConstraint.java
===================================================================
---
mmbase/branches/MMBase-1_9/core/src/main/java/org/mmbase/storage/search/implementation/BasicFieldValueConstraint.java
2010-06-21 09:47:28 UTC (rev 42625)
+++
mmbase/branches/MMBase-1_9/core/src/main/java/org/mmbase/storage/search/implementation/BasicFieldValueConstraint.java
2010-06-21 09:52:20 UTC (rev 42626)
@@ -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,6 +25,8 @@
*/
public class BasicFieldValueConstraint extends BasicFieldCompareConstraint
implements FieldValueConstraint, java.io.Serializable {
+ private static final Logger log =
Logging.getLoggerInstance(BasicFieldValueConstraint.class);
+
/** The value. */
private Object value = null;
@@ -59,6 +65,117 @@
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;
+ }
+
+
// javadoc is inherited
public boolean equals(Object obj) {
// Must be same class (subclasses should override this)!
_______________________________________________
Cvs mailing list
[email protected]
http://lists.mmbase.org/mailman/listinfo/cvs
