Wrapper to addParameter()

@param param
@param value
@return
@throws URISyntaxException
167033
public UriBuilder queryParam(String param, String value) throws URISyntaxException {
        if (StringUtils.isNotBlank(param) && StringUtils.isNotBlank(value)) {
            return new UriBuilder(addParameter(param, value));
        } else {
            return this;
        }
    }
552450
public static Response post(URI uri)
        throws URISyntaxException, UnsupportedEncodingException, HttpException {
        return postParams(new HttpPost(uri), new ArrayList<NameValuePair>(), null, null);
    }
528268
public URIBuilder addParameter( String key, String value )
    {
        if ( key != null && value != null ) {
            queryParams.put( key, value );
        }

        return this;
    }
1355165
public static void addValue(String key, Object value, MultiValueMap<String, String> params) {
        if (value != null) {
            params.add(key, value.toString());
        }
    }
243225
public void addInitParam(final WebAppInitParam param) {
		NullArgumentException.validateNotNull(param, "Init param");
		NullArgumentException.validateNotNull(param.getParamName(),
				"Init param name");
		NullArgumentException.validateNotNull(param.getParamValue(),
				"Init param value");
		initParams.add(param);
	}
774428
public B addParameter(final String paramName, final String paramValue) {
        httpParams.addParameter(paramName, paramValue);
        return self();
    }
638541
private void addParams(RequestBuilder call, Param[] params) {
		
		// Once upon a time this was necessary, now it isn't
		//call.addParam("format", "json");
		
		if (this.accessToken != null)
			call.addParam("access_token", this.accessToken);

		if (this.appSecretProof != null)
			call.addParam("appsecret_proof", this.appSecretProof);

		if (params != null) {
			for (Param param: params) {
				if (param instanceof BinaryParam) {
					call.addParam(param.name, (InputStream)param.value, ((BinaryParam)param).contentType, "irrelevant");
				} else {
					String paramValue = StringUtils.stringifyValue(param, this.mapper);
					call.addParam(param.name, paramValue);
				}
			}
		}
	}
249627
public HttpRequest addQueryParameter(String name, String value) {
    queryParameters.put(
        Objects.requireNonNull(name, "Name must be set"),
        Objects.requireNonNull(value, "Value must be set"));
    return this;
  }
796094
public UrlStringBuilder addParameter(String name, String... values) {
        this.addParameter(name, values != null ? Arrays.asList(values) : null);
        return this;
    }
1127203
public static String addParameter(final String url, final String name, final String value) {
        if (url != null) {
            final StringBuilder sb = new StringBuilder();
            sb.append(url);
            if (name != null) {
                if (url.indexOf("?") >= 0) {
                    sb.append("&");
                } else {
                    sb.append("?");
                }
                sb.append(name);
                sb.append("=");
                if (value != null) {
                    sb.append(urlEncode(value));
                }
            }
            return sb.toString();
        }
        return null;
    }
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));
    }
507334
private URL buildUriWithParameters(URL url, Map<String, String> params) throws URISyntaxException, MalformedURLException {
        if (params == null || params.isEmpty()) {
            return url;
        }
        URIBuilder uriBuilder = new URIBuilder(url.toURI());
        for (String paramName : params.keySet()) {
            uriBuilder.addParameter(paramName, params.get(paramName));
        }
        return uriBuilder.build().toURL();
    }
1178928
public void addValue(
                    final Object value
                    )
    {
        if (value == null) {
            setNullContained( true );
        } else {
            _values.add( String.valueOf( value ) );
        }
    }
389264
private void _buildParameter(
                    final Object value,
                    final StringBuilder stmt,
                    final List<Object> params
                    )
    {
        params.add( value );
        stmt.append( _PARAM_SIGN_ ).append( params.size() );
    }
1289642
public void addParameter(ISUPParameter param) throws ParameterException {
        if (param == null) {
            throw new IllegalArgumentException("Argument must not be null");
        }
        int paramCode = param.getCode();
        if (this.mandatoryCodes.contains(paramCode)) {
            int index = this.mandatoryCodeToIndex.get(paramCode);
            this.f_Parameters.put(index, (AbstractISUPParameter) param);
            return;
        }

        if (this.mandatoryVariableCodes.contains(paramCode)) {
            int index = this.mandatoryVariableCodeToIndex.get(paramCode);
            this.v_Parameters.put(index, (AbstractISUPParameter) param);
            return;
        }
        if (this.optionalCodes.contains(paramCode)) {
            int index = this.optionalCodeToIndex.get(paramCode);
            this.o_Parameters.put(index, (AbstractISUPParameter) param);
            return;
        }

        throw new ParameterException("Parameter with code: " + paramCode
                + " is not defined in any type: mandatory, mandatory variable or optional");
    }
221429
void addParameter(String name, String value) {
        params.add(new Parameter(name, value));
    }
1168060
public void addParamPost(String name, String value) {
        addParam(name, value, NameValuePair.TYPE_POST_DATA);
    }