1 package com.indexdata.mkjsf.pazpar2.commands;
\r
3 import java.io.Serializable;
\r
4 import java.io.UnsupportedEncodingException;
\r
5 import java.net.URLEncoder;
\r
6 import java.util.ArrayList;
\r
7 import java.util.Arrays;
\r
8 import java.util.Iterator;
\r
9 import java.util.List;
\r
11 import org.apache.log4j.Logger;
\r
14 * Represents a Pazpar2 command parameter with a name, an operator,
\r
15 * a simple value and/or one or more complex values (expressions).
\r
16 * <p><i>Examples:</i></p>
\r
18 * <li><code>{name}{=}{value}</code></li>
\r
19 * <li><code>{name}{=}{value} AND {expr1=value1} AND {expr2=value2}</code></li>
\r
20 * <li><code>{name}{=}{expr1~value1},{expr2~value2}</code></li>
\r
22 * @author Niels Erik
\r
25 public class CommandParameter implements Serializable {
\r
27 private static Logger logger = Logger.getLogger(CommandParameter.class);
\r
29 private static final long serialVersionUID = 625502285668766749L;
\r
31 String operator = null;
\r
32 String value = null;
\r
33 List<Expression> expressions = new ArrayList<Expression>();
\r
34 private static List<String> nologparams = Arrays.asList("password");
\r
36 public CommandParameter (String name) {
\r
37 logger.trace("Instantiating command parameter '" + name + "'");
\r
42 * Instantiates a parameter with a simple value and one or more expressions
\r
47 * @param expressions
\r
49 public CommandParameter (String name, String operator, String value, Expression... expressions) {
\r
50 logger.trace("Instantiating command parameter " + name + " with value [" + value + "] and expressions: [" + expressions + "]");
\r
52 this.operator = operator;
\r
54 for (Expression expr : expressions) {
\r
55 this.expressions.add(expr);
\r
60 * Instantiates a parameter with one or more expressions
\r
63 * @param expressions
\r
65 public CommandParameter (String name, String operator, Expression... expressions) {
\r
66 logger.trace("Instantiating command parameter " + name + " with expressions: [" + expressions + "]");
\r
68 this.operator = operator;
\r
69 for (Expression expr : expressions) {
\r
70 this.expressions.add(expr);
\r
76 * Instantiates a parameter with a simple value
\r
81 public CommandParameter (String name, String operator, String value) {
\r
82 if (!nologparams.contains(name)) logger.trace("Instantiating command parameter '" + name + "' with String: [" + value + "]");
\r
84 this.operator = operator;
\r
85 this.value = value;
\r
89 * Instantiates a parameter with a numeric value
\r
94 public CommandParameter (String name, String operator, int value) {
\r
95 logger.trace("Instantiating command parameter '" + name + "' with int: [" + value + "]");
\r
97 this.operator = operator;
\r
98 this.value = value+"";
\r
102 * Returns the name (left of operator) of this parameter
\r
104 * @return name (left of operator) of this parameter
\r
106 public String getName () {
\r
111 * Returns a list of all current expressions
\r
113 * @return a list of all current expressions
\r
115 public List<Expression> getExpressions () {
\r
116 return expressions;
\r
120 * Returns expressions selected by their left-hand keys - as in 'expressionField=value'.
\r
122 * If the parameter has expressions expr1=x,expr2=y,expr3=z,expr1=u then invoking this method
\r
123 * with {"expr1","expr3"} would return expr1=x,expr3=z,expr1=u but not expr2=y.
\r
125 * @param expressionFields The expression types to return
\r
126 * @return a list of expressions with the given keys to the left of the operator
\r
129 public List<Expression> getExpressions(String... expressionFields) {
\r
130 List<String> requestedFields = Arrays.asList(expressionFields);
\r
131 List<Expression> exprs = new ArrayList<Expression>();
\r
132 for (Expression expr : expressions) {
\r
133 if (requestedFields.contains(expr.getField())) {
\r
141 * Adds an expression to the end of the list of current expressions (if any)
\r
143 * @param expression to add
\r
145 public void addExpression(Expression expression) {
\r
146 logger.debug("Adding expression [" + expression + "] to '" + name + "'");
\r
147 this.expressions.add(expression);
\r
151 * Removes a single expression identified by all its characteristics
\r
153 * @param expression to remove
\r
155 public void removeExpression(Expression expression) {
\r
156 for (Expression expr : expressions) {
\r
157 if (expr.toString().equals(expression.toString())) {
\r
158 expressions.remove(expr);
\r
165 * Removes all expressions that appear after the provided expression and that
\r
166 * have the given keys to the left of their operators - as in 'expressionField=value'.
\r
168 * This method is intended for bread crumb-like UI controls
\r
170 * @param expression The expression to use a starting point for removal (not inclusive)
\r
171 * @param expressionFields The expression fields to remove
\r
173 public void removeExpressionsAfter (Expression expression, String... expressionFields) {
\r
174 List<String> exprFieldsToRemove = Arrays.asList(expressionFields);
\r
176 for (Expression expr : expressions) {
\r
178 if (expr.toString().equals(expression.toString())) {
\r
182 if (fromIdx<expressions.size()) {
\r
183 Iterator<Expression> candidatesForRemoval = expressions.subList(fromIdx, expressions.size()).iterator();
\r
184 while (candidatesForRemoval.hasNext()) {
\r
185 Expression exp = candidatesForRemoval.next();
\r
186 if (exprFieldsToRemove.contains(exp.getField())) {
\r
187 expressions.remove(exp);
\r
194 * Removes expressions selected by their left-of-operator fields/keys - as in 'expressionField=value'.
\r
196 * If the parameter has expressions expr1=x,expr2=y,expr3=z,expr1=u then invoking this method
\r
197 * with {"expr1","expr3"} would remove expr1=x,expr3=z and expr1=u but leave expr2=y.
\r
199 * @param expressionFields The expression types (by field) to remove
\r
200 * @return a list of expressions with the given left-of-operator keys
\r
203 public void removeExpressions (String... expressionFields) {
\r
204 List<String> fieldsToRemove = Arrays.asList(expressionFields);
\r
205 Iterator<Expression> i = expressions.iterator();
\r
206 while (i.hasNext()) {
\r
207 Expression expr = i.next();
\r
208 if (fieldsToRemove.contains(expr.getField())) {
\r
209 logger.trace("Removing expression: " + expr.toString());
\r
217 * @return true if an operator was defined for this parameter yet
\r
219 public boolean hasOperator() {
\r
220 return operator != null;
\r
224 * Returns true if this parameter has a simple value
\r
226 * @return true if this parameter has a simple value
\r
228 public boolean hasValue() {
\r
229 return value != null && value.length()>0;
\r
233 * Returns true if this parameter has expressions (complex values)
\r
235 * @return true if this parameter has expressions (complex values)
\r
237 public boolean hasExpressions() {
\r
238 return expressions.size()>0;
\r
242 * Returns true if this parameter has expressions of the given type,
\r
243 * that is, expressions where the left-of-operator key equals 'expressionField'
\r
245 * @param expressionField the type of expression to look for
\r
246 * @return true if this parameter has expressions of the given type,
\r
247 * that is, expressions where the left-of-operator key equals 'expressionField'
\r
249 public boolean hasExpressions(String expressionField) {
\r
250 for (Expression expr : expressions) {
\r
251 if (expr.getField().equals(expressionField)) {
\r
259 * Returns a URL encoded string of this parameter with name, operator, simple value and/or expressions
\r
261 * @return URL encoded string of this parameter with name, operator, simple value and/or expressions
\r
263 public String getEncodedQueryString () {
\r
265 return name + operator + URLEncoder.encode(getValueWithExpressions(),"UTF-8");
\r
266 } catch (UnsupportedEncodingException e) {
\r
267 e.printStackTrace();
\r
273 * Returns the simple parameter value or null if no simple value was set for this parameter
\r
275 * @return the simple parameter value, null if no simple value was set for this parameter
\r
277 public String getSimpleValue() {
\r
282 * Returns the simple parameter value and/or any expressions, separated by 'AND'
\r
284 * @return the simple parameter value and/or any expressions separated by 'AND'
\r
286 public String getValueWithExpressions () {
\r
287 StringBuilder completeValue = new StringBuilder((value==null ? "" : value));
\r
288 boolean first=true;
\r
289 for (Expression expr : expressions) {
\r
290 if (value == null && first) {
\r
292 completeValue.append(expr.toString());
\r
294 completeValue.append(" AND " + expr.toString());
\r
297 return completeValue.toString();
\r
301 public boolean equals (Object otherParameter) {
\r
303 ((otherParameter instanceof CommandParameter)
\r
304 && this.getValueWithExpressions().equals(((CommandParameter) otherParameter).getValueWithExpressions()));
\r
308 public int hashCode () {
\r
309 return getValueWithExpressions().hashCode();
\r
312 public String toString() {
\r
313 return getValueWithExpressions();
\r
317 * Clones the CommandParameter
\r
319 * @return a deep, detached clone of this command parameter, for copying
\r
320 * a parameter to a new state.
\r
322 public CommandParameter copy() {
\r
323 logger.trace("Copying parameter '"+ name + "' for modification");
\r
324 CommandParameter newParam = new CommandParameter(name);
\r
325 newParam.value = this.value;
\r
326 newParam.operator = this.operator;
\r
327 for (Expression expr : expressions) {
\r
328 newParam.addExpression(expr.copy());
\r