getExpressions () {
return expressions;
}
+
+ /**
+ * Returns expressions selected by their left-hand keys - as in 'expressionField=value'.
+ *
+ * If the parameter has expressions expr1=x,expr2=y,expr3=z,expr1=u then invoking this method
+ * with {"expr1","expr3"} would return expr1=x,expr3=z,expr1=u but not expr2=y.
+ *
+ * @param expressionFields The expression types to return
+ * @return a list of expressions with the given keys to the left of the operator
+ *
+ */
+ public List getExpressions(String... expressionFields) {
+ List requestedFields = Arrays.asList(expressionFields);
+ List exprs = new ArrayList();
+ for (Expression expr : expressions) {
+ if (requestedFields.contains(expr.getField())) {
+ exprs.add(expr);
+ }
+ }
+ return exprs;
+ }
+ /**
+ * Adds an expression to the end of the list of current expressions (if any)
+ *
+ * @param expression to add
+ */
public void addExpression(Expression expression) {
logger.debug("Adding expression [" + expression + "] to '" + name + "'");
- this.expressions.put(expression.toString(),expression);
+ this.expressions.add(expression);
}
+ /**
+ * Removes a single expression identified by all its characteristics
+ *
+ * @param expression to remove
+ */
public void removeExpression(Expression expression) {
- this.expressions.remove(expression.toString());
+ for (Expression expr : expressions) {
+ if (expr.toString().equals(expression.toString())) {
+ expressions.remove(expr);
+ break;
+ }
+ }
}
+ /**
+ * Removes all expressions that appear after the provided expression and that
+ * have the given keys to the left of their operators - as in 'expressionField=value'.
+ *
+ * This method is intended for bread crumb-like UI controls
+ *
+ * @param expression The expression to use a starting point for removal (not inclusive)
+ * @param expressionFields The expression fields to remove
+ */
+ public void removeExpressionsAfter (Expression expression, String... expressionFields) {
+ List exprFieldsToRemove = Arrays.asList(expressionFields);
+ int fromIdx = 0;
+ for (Expression expr : expressions) {
+ fromIdx++;
+ if (expr.toString().equals(expression.toString())) {
+ break;
+ }
+ }
+ if (fromIdx candidatesForRemoval = expressions.subList(fromIdx, expressions.size()).iterator();
+ while (candidatesForRemoval.hasNext()) {
+ Expression exp = candidatesForRemoval.next();
+ if (exprFieldsToRemove.contains(exp.getField())) {
+ expressions.remove(exp);
+ }
+ }
+ }
+ }
+ /**
+ * Removes expressions selected by their left-of-operator fields/keys - as in 'expressionField=value'.
+ *
+ * If the parameter has expressions expr1=x,expr2=y,expr3=z,expr1=u then invoking this method
+ * with {"expr1","expr3"} would remove expr1=x,expr3=z and expr1=u but leave expr2=y.
+ *
+ * @param expressionFields The expression types (by field) to remove
+ * @return a list of expressions with the given left-of-operator keys
+ *
+ */
+ public void removeExpressions (String... expressionFields) {
+ List fieldsToRemove = Arrays.asList(expressionFields);
+ Iterator i = expressions.iterator();
+ while (i.hasNext()) {
+ Expression expr = i.next();
+ if (fieldsToRemove.contains(expr.getField())) {
+ logger.trace("Removing expression: " + expr.toString());
+ i.remove();
+ }
+ }
+ }
+
+ /**
+ *
+ * @return true if an operator was defined for this parameter yet
+ */
public boolean hasOperator() {
return operator != null;
}
+ /**
+ * Returns true if this parameter has a simple value
+ *
+ * @return true if this parameter has a simple value
+ */
+ public boolean hasValue() {
+ return value != null && value.length()>0;
+ }
+
+ /**
+ * Returns true if this parameter has expressions (complex values)
+ *
+ * @return true if this parameter has expressions (complex values)
+ */
+ public boolean hasExpressions() {
+ return expressions.size()>0;
+ }
+
+ /**
+ * Returns true if this parameter has expressions of the given type,
+ * that is, expressions where the left-of-operator key equals 'expressionField'
+ *
+ * @param expressionField the type of expression to look for
+ * @return true if this parameter has expressions of the given type,
+ * that is, expressions where the left-of-operator key equals 'expressionField'
+ */
+ public boolean hasExpressions(String expressionField) {
+ for (Expression expr : expressions) {
+ if (expr.getField().equals(expressionField)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Returns a URL encoded string of this parameter with name, operator, simple value and/or expressions
+ *
+ * @return URL encoded string of this parameter with name, operator, simple value and/or expressions
+ */
public String getEncodedQueryString () {
try {
return name + operator + URLEncoder.encode(getValueWithExpressions(),"UTF-8");
@@ -81,18 +269,33 @@ public class CommandParameter implements Serializable {
}
}
+ /**
+ * Returns the simple parameter value or null if no simple value was set for this parameter
+ *
+ * @return the simple parameter value, null if no simple value was set for this parameter
+ */
public String getSimpleValue() {
return value;
}
+ /**
+ * Returns the simple parameter value and/or any expressions, separated by 'AND'
+ *
+ * @return the simple parameter value and/or any expressions separated by 'AND'
+ */
public String getValueWithExpressions () {
- StringBuilder completeValue = new StringBuilder((value==null ? "" : value));
- for (String key : expressions.keySet()) {
- completeValue.append(" and " + expressions.get(key));
+ StringBuilder completeValue = new StringBuilder((value==null ? "" : value));
+ boolean first=true;
+ for (Expression expr : expressions) {
+ if (value == null && first) {
+ first = false;
+ completeValue.append(expr.toString());
+ } else {
+ completeValue.append(" AND " + expr.toString());
+ }
}
- return completeValue.toString();
-
- }
+ return completeValue.toString();
+ }
@Override
public boolean equals (Object otherParameter) {
@@ -110,13 +313,19 @@ public class CommandParameter implements Serializable {
return getValueWithExpressions();
}
+ /**
+ * Clones the CommandParameter
+ *
+ * @return a deep, detached clone of this command parameter, for copying
+ * a parameter to a new state.
+ */
public CommandParameter copy() {
- logger.debug("Copying parameter '"+ name + "' for modification");
+ logger.trace("Copying parameter '"+ name + "' for modification");
CommandParameter newParam = new CommandParameter(name);
newParam.value = this.value;
newParam.operator = this.operator;
- for (String key : expressions.keySet()) {
- newParam.addExpression(expressions.get(key).copy());
+ for (Expression expr : expressions) {
+ newParam.addExpression(expr.copy());
}
return newParam;
}