Adds a query parameter that will have it's value injected from the provider state
@param name Name
@param expression Expression to be evaluated from the provider state
@param example Example value to use in the consumer test
357595
public PactDslRequestWithoutPath queryParameterFromProviderState(String name, String expression, String example) {
    requestGenerators.addGenerator(Category.QUERY, name, new ProviderStateGenerator(expression));
    query.put(name, Collections.singletonList(example));
    return this;
  }
129481
protected String putExpressionAttributeValue(AttributeValue expressionAttributeValue) {
        String expressionAttributeValueKey = getExpressionAttributeValuePrefix() + expressionAttributeValueCounter++;

        expressionAttributeValues.put(expressionAttributeValueKey, expressionAttributeValue);

        return expressionAttributeValueKey;
    }
750594
public void addParam(String name, String value) {
        if (name == null) {
            throw new NullPointerException("name");
        }
        if (value == null) {
            throw new NullPointerException("value");
        }
        params.add(new Param(name, value));
    }
433406
@Deprecated
    public static ExpressionEvaluator getEvaluatorByName(String name) throws JspException {
        try {
            ExpressionEvaluator evaluator = nameMap.get(name);
            if (evaluator == null) {
                nameMap.putIfAbsent(name, (ExpressionEvaluator) Class.forName(name).newInstance());
                evaluator = nameMap.get(name);
            }
            return evaluator;
        } catch (ClassCastException ex) {
            // just to display a better error message
            throw new JspException("invalid ExpressionEvaluator: " + name, ex);
        } catch (ClassNotFoundException ex) {
            throw new JspException("couldn't find ExpressionEvaluator: " + name, ex);
        } catch (IllegalAccessException ex) {
            throw new JspException("couldn't access ExpressionEvaluator: " + name, ex);
        } catch (InstantiationException ex) {
            throw new JspException("couldn't instantiate ExpressionEvaluator: " + name, ex);
        }
    }
731434
public QueryParameterWrap addParameters(String name, Object[] values) {
		this.namedParameter.put(name, values);
		return this;
	}
242523
public void addQueryParam( String paramName, String value )
    {
        if ( _queryString == null )
        {
            _queryString = new InternalStringBuilder( "?" );
        }
        else
        {
            _queryString.append( '&' );
        }
        
        _queryString.append( paramName );
        
        if ( value != null )
        {
            _queryString.append( '=' ).append( value );
        }
    }
532667
def add_parameter(self, name, value=None):
		
		if name not in self.__query:
			self.__query[name] = [value]
		else:
			self.__query[name].append(value)
273075
function(expression) {
			var pastedExpression = new Expression();
			var key = this._getKey();

			pastedExpression.fromJson(json.parse(localStorage[key]));
			var newExpression;
			if (expression) {
				var expressionClone = new Expression({
					operator : 'and',
					expressionList : [expression, pastedExpression]
				}).toJson();
				//converting the same instance
				expression.fromJson(expressionClone);
				newExpression = expression;
			} else {
				newExpression = pastedExpression;
			}

			var parentBuilder = this.get('filterBuilder');

			parentBuilder.set('expression', newExpression, true /* preventChange Undo State
			 * */);
		}
621703
public static QueryBuilder byInstanceId(Object localId, String typeName){
        Validate.argumentsAreNotNull(localId, typeName);
        return new QueryBuilder(new IdAndTypeNameFilterDefinition(localId, typeName));
    }
621605
public T query(String name, Object value) {
        this.query(name, value, true);
        return returnThis();
    }
511244
public void addFilter(String name, String value, SearchCriteriaFilterOperator operator) {
        SearchCriteriaFilterBean filter = new SearchCriteriaFilterBean();
        filter.setName(name);
        filter.setValue(value);
        filter.setOperator(operator);
        filters.add(filter);
    }
1206687
public Hedge addHedge(String name, String arg, String expression) {
		return addHedge(new Hedge(name, arg, expression));
	}
1305325
public static void forceCastForName(String nameRef, Type type, Expression expression) {
        List<NameExpr> allNameExprForName = expression.findAll(NameExpr.class, n -> n.getNameAsString().equals(nameRef));
        for (NameExpr n : allNameExprForName) {
            n.getParentNode().get().replace(n, new EnclosedExpr(new CastExpr(type, n)));
        }
    }
141414
public function addExpression($name, $expression = null)
    {
        /** @type Field_Expression $f */
        $f = $this->add('Field_Expression', $name);

        return $f->set($expression);
    }
1018330
private QueryBuilder populateLikeQuery(LikeExpression likeExpression, EntityMetadata metadata)
    {
        Expression patternValue = likeExpression.getPatternValue();
        String field = likeExpression.getStringExpression().toString();

        String likePattern = (patternValue instanceof InputParameter) ? kunderaQuery.getParametersMap()
                .get((patternValue).toParsedText()).toString() : patternValue.toParsedText().toString();
        String jpaField = getField(field);

        log.debug("Pattern value for field " + field + " is: " + patternValue);
        QueryBuilder filterBuilder = getQueryBuilder(kunderaQuery.new FilterClause(jpaField, Expression.LIKE,
                likePattern, field), metadata);

        return filterBuilder;
    }
1089570
public URIBuilder queryParam(String name, String value) {
		parameters.add(name, value);
		return this;
	}
293189
private boolean validInstanceOfExpression(Node expr) {
    // The expression must have two children:
    // - The instanceOf keyword
    // - A string
    if (!checkParameterCount(expr, Keywords.INSTANCEOF)) {
      return false;
    }
    if (!validTypeTransformationExpression(getCallArgument(expr, 0))) {
      warnInvalidInside(Keywords.INSTANCEOF.name, expr);
      return false;
    }
    return true;
  }