/** * Return a name/value string suitable for sending in a <tt>"Cookie"</tt> * header as defined in RFC 2109 for backward compatibility with cookie * version 0 * @param buffer The string buffer to use for output * @param param The parameter. * @param version The cookie version */ private void formatParam(final StringBuffer buffer, final NameValuePair param, int version) { if (version < 1) { buffer.append(param.getName()); buffer.append("="); if (param.getValue() != null) { buffer.append(param.getValue()); } } else { this.formatter.format(buffer, param); } }
&& paramValue.equals(pair.getValue())) { iter.remove(); return true;
/** * Produces textual representaion of the attribute/value pair using * formatting rules defined in RFC 2616 * * @param buffer output buffer * @param param the parameter to be formatted */ public void format(final StringBuffer buffer, final NameValuePair param) { if (buffer == null) { throw new IllegalArgumentException("String buffer may not be null"); } if (param == null) { throw new IllegalArgumentException("Parameter may not be null"); } buffer.append(param.getName()); String value = param.getValue(); if (value != null) { buffer.append("="); formatValue(buffer, value, this.alwaysUseQuotes); } }
/** * Adds a new parameter to be used in the POST request body. * * @param param The parameter to add. * * @throws IllegalArgumentException if the argument is null or contains * null values * * @since 2.0 */ public void addParameter(NameValuePair param) throws IllegalArgumentException { LOG.trace("enter PostMethod.addParameter(NameValuePair)"); if (param == null) { throw new IllegalArgumentException("NameValuePair may not be null"); } addParameter(param.getName(), param.getValue()); }
/** * Extracts a map of challenge parameters from an authentication challenge. * Keys in the map are lower-cased * * @param challengeStr the authentication challenge string * @return a map of authentication challenge parameters * @throws MalformedChallengeException when the authentication challenge string * is malformed * * @since 2.0beta1 */ public static Map extractParams(final String challengeStr) throws MalformedChallengeException { if (challengeStr == null) { throw new IllegalArgumentException("Challenge may not be null"); } int idx = challengeStr.indexOf(' '); if (idx == -1) { throw new MalformedChallengeException("Invalid challenge: " + challengeStr); } Map map = new HashMap(); ParameterParser parser = new ParameterParser(); List params = parser.parse( challengeStr.substring(idx + 1, challengeStr.length()), ','); for (int i = 0; i < params.size(); i++) { NameValuePair param = (NameValuePair) params.get(i); map.put(param.getName().toLowerCase(), param.getValue()); } return map; }
this.charset = charsetPair.getValue(); } else if (charset != null && charsetPair == null) {
/** * Constructor with array of characters. * * @param chars the array of characters * @param offset - the initial offset. * @param length - the length. * * @since 3.0 */ public HeaderElement(char[] chars, int offset, int length) { this(); if (chars == null) { return; } ParameterParser parser = new ParameterParser(); List params = parser.parse(chars, offset, length, ';'); if (params.size() > 0) { NameValuePair element = (NameValuePair) params.remove(0); setName(element.getName()); setValue(element.getValue()); if (params.size() > 0) { this.parameters = (NameValuePair[]) params.toArray(new NameValuePair[params.size()]); } } }
final String paramValue = attribute.getValue();
final String paramValue = attribute.getValue();
/** * Returns the character set from the <tt>Content-Type</tt> header. * * @param contentheader The content header. * @return String The character set. */ protected String getContentCharSet(Header contentheader) { LOG.trace("enter getContentCharSet( Header contentheader )"); String charset = null; if (contentheader != null) { HeaderElement values[] = contentheader.getElements(); // I expect only one header element to be there // No more. no less if (values.length == 1) { NameValuePair param = values[0].getParameterByName("charset"); if (param != null) { // If I get anything "funny" // UnsupportedEncondingException will result charset = param.getValue(); } } } if (charset == null) { charset = getParams().getContentCharset(); if (LOG.isDebugEnabled()) { LOG.debug("Default charset used: " + charset); } } return charset; }
final String paramValue = attribute.getValue();
String paramValue = attribute.getValue();
/** * Builds parameters string with command and encoded param values * @param command * @param params * @return */ protected static String buildParams(String command, List<NameValuePair> params) { StringBuffer paramString = new StringBuffer("command=" + command); Iterator<NameValuePair> iter = params.iterator(); try { while (iter.hasNext()) { NameValuePair param = iter.next(); if (param.getValue() != null && !(param.getValue().isEmpty())) { paramString.append("&" + param.getName() + "=" + URLEncoder.encode(param.getValue(), "UTF-8")); } } } catch (UnsupportedEncodingException e) { s_logger.error(e.getMessage()); return null; } return paramString.toString(); }
/** * @return */ public boolean hasResponse() { NameValuePair pair = postMethod.getResponseHeader("Content-Type"); if(pair == null) return false; String ct = pair.getValue(); return ct != null && ct.length() > 0; }
@Override public void process(Exchange exchange) throws Exception { HashMap<String, String> result = new HashMap<String, String>(); for (NameValuePair pairs : (List<NameValuePair>) parser.parse(exchange.getIn().getHeader(Exchange.HTTP_QUERY, String.class), '&')) { result.put(pairs.getName(), pairs.getValue()); } exchange.getIn().setHeader(QueryMapHeader, result); } }
/** * {@inheritDoc} */ public String getResponseHeaderValue(final String headerName) { for (final NameValuePair pair : responseData_.getResponseHeaders()) { if (pair.getName().equalsIgnoreCase(headerName)) { return pair.getValue(); } } return null; }
/** * {@inheritDoc} */ public String getResponseHeaderValue(final String headerName) { for (final NameValuePair pair : responseData_.getResponseHeaders()) { if (pair.getName().equalsIgnoreCase(headerName)) { return pair.getValue(); } } return null; }
protected boolean isResponseGzipCompressed() { Header h = method.getResponseHeader( "Content-Encoding" ); if (h == null) { return false; } else { return HttpUtil.isUsingGzipEncoding(h.getValue()); } }
private String processCookieHeader(HeaderElement element) { String cookie = element.getName() + "=" + element.getValue(); NameValuePair[] parameters = element.getParameters(); for (int j = 0; parameters != null && j < parameters.length; j++) { NameValuePair parameter = parameters[j]; cookie = cookie + "; " + parameter.getName() + "=" + parameter.getValue(); } return cookie; }