Condition condition;
/*
- * the string value (upper-cased), or the regex, to compare to
+ * the string pattern as entered, or the regex, to compare to
* also holds the string form of float value if a numeric condition
*/
String pattern;
/*
+ * the pattern in upper case, for non-case-sensitive matching
+ */
+ String uppercasePattern;
+
+ /*
* the compiled regex if using a pattern match condition
* (reserved for possible future enhancement)
*/
* @return
* @throws NumberFormatException
* if a numerical condition is specified with a non-numeric
- * comparision value
+ * comparison value
* @throws NullPointerException
- * if a null comparison string is specified
+ * if a null condition or comparison string is specified
*/
public Matcher(Condition cond, String compareTo)
{
+ Objects.requireNonNull(cond);
condition = cond;
if (cond.isNumeric())
{
value = Float.valueOf(compareTo);
pattern = String.valueOf(value);
+ uppercasePattern = pattern;
}
else
{
- // pattern matches will be non-case-sensitive
- pattern = compareTo.toUpperCase();
+ pattern = compareTo;
+ if (pattern != null)
+ {
+ uppercasePattern = pattern.toUpperCase();
+ }
}
// if we add regex conditions (e.g. matchesPattern), then
*/
public Matcher(Condition cond, float compareTo)
{
- Objects.requireNonNull(cond);
- condition = cond;
- value = compareTo;
- pattern = String.valueOf(compareTo).toUpperCase();
+ this(cond, String.valueOf(compareTo));
}
/**
if (val == null)
{
return condition == Condition.NotContains
- || condition == Condition.NotMatches;
+ || condition == Condition.NotMatches
+ || condition == Condition.NotPresent;
}
String upper = val.toUpperCase().trim();
boolean matched = false;
switch(condition) {
case Matches:
- matched = upper.equals(pattern);
+ matched = upper.equals(uppercasePattern);
break;
case NotMatches:
- matched = !upper.equals(pattern);
+ matched = !upper.equals(uppercasePattern);
break;
case Contains:
- matched = upper.indexOf(pattern) > -1;
+ matched = upper.indexOf(uppercasePattern) > -1;
break;
case NotContains:
- matched = upper.indexOf(pattern) == -1;
+ matched = upper.indexOf(uppercasePattern) == -1;
+ break;
+ case Present:
+ matched = true;
+ break;
+ default:
break;
}
return matched;
case GE:
matched = f >= value;
break;
+ default:
+ break;
}
return matched;
/**
* equals is overridden so that we can safely remove Matcher objects from
- * collections (e.g. delete an attribut match condition for a feature colour)
+ * collections (e.g. delete an attribute match condition for a feature colour)
*/
@Override
public boolean equals(Object obj)
return false;
}
Matcher m = (Matcher) obj;
- return condition == m.condition && value == m.value
- && pattern.equals(m.pattern);
+ if (condition != m.condition || value != m.value)
+ {
+ return false;
+ }
+ if (pattern == null)
+ {
+ return m.pattern == null;
+ }
+ return uppercasePattern.equals(m.uppercasePattern);
}
@Override
@Override
public String toString()
{
- return condition.name() + " " + pattern;
+ StringBuilder sb = new StringBuilder();
+ sb.append(condition.toString()).append(" ");
+ if (condition.isNumeric())
+ {
+ sb.append(pattern);
+ }
+ else
+ {
+ sb.append("'").append(pattern).append("'");
+ }
+
+ return sb.toString();
}
}