apache.http.util.CharArrayBuffer;

@NotThreadSafe
public class BufferedHeader
  implements FormattedHeader, Cloneable, Serializable
{
  private static final long serialVersionUID = -2768352615787625448L;
  private final String name;
  private final CharArrayBuffer buffer;
  private final int valuePos;
  
  public BufferedHeader(CharArrayBuffer buffer)
    throws ParseException
  {
    Args.notNull(buffer, "Char array buffer");
    int colon = buffer.indexOf(58);
    if (colon == -1) {
      throw new ParseException("Invalid header: " + buffer.toString());
    }
    String s = buffer.substringTrimmed(0, colon);
    if (s.length() == 0) {
      throw new ParseException("Invalid header: " + buffer.toString());
    }
    this.buffer = buffer;
    name = s;
    valuePos = (colon + 1);
  }
  
  public String getName()
  {
    return name;
  }
  
  public String getValue()
  {
    return buffer.substringTrimmed(valuePos, buffer.length());
  }
  
  public HeaderElement[] getElements()
    throws ParseException
  {
    ParserCursor cursor = new ParserCursor(0, buffer.length());
    cursor.updatePos(valuePos);
    return BasicHeaderValueParser.INSTANCE.parseElements(buffer, cursor);
  }
  
  public int getValuePos()
  {
    return valuePos;
  }
  
  public CharArrayBuffer getBuffer()
  {
    return buffer;
  }
  
  public String toString()
  {
    return buffer.toString();
  }
  
  public Object clone()
    throws CloneNotSupportedException
  {
    return super.clone();
  }
}

/* Location:
 * Qualified Name:     org.apache.http.message.BufferedHeader
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.apache.http.message;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Locale;
import org.apache.http.Header;
import org.apache.http.HeaderIterator;
import org.apache.http.annotation.NotThreadSafe;
import org.apache.http.util.CharArrayBuffer;

@NotThreadSafe
public class HeaderGroup
  implements Cloneable, Serializable
{
  private static final long serialVersionUID = 2608834160639271617L;
  private final List<Header> headers;
  
  public HeaderGroup()
  {
    headers = new ArrayList(16);
  }
  
  public void clear()
  {
    headers.clear();
  }
  
  public void addHeader(Header header)
  {
    if (header == null) {
      return;
    }
    headers.add(header);
  }
  
  public void removeHeader(Header header)
  {
    if (header == null) {
      return;
    }
    headers.remove(header);
  }
  
  public void updateHeader(Header header)
  {
    if (header == null) {
      return;
    }
    for (int i = 0; i < headers.size(); i++)
    {
      Header current = (Header)headers.get(i);
      if (current.getName().equalsIgnoreCase(header.getName()))
      {
        headers.set(i, header);
        return;
      }
    }
    headers.add(header);
  }
  
  public void setHeaders(Header[] headers)
  {
    clear();
    if (headers == null) {
      return;
    }
    Collections.addAll(this.headers, headers);
  }
  
  public Header getCondensedHeader(String name)
  {
    Header[] hdrs = getHeaders(name);
    if (hdrs.length == 0) {
      return null;
    }
    if (hdrs.length == 1) {
      return hdrs[0];
    }
    CharArrayBuffer valueBuffer = new CharArrayBuffer(128);
    valueBuffer.append(hdrs[0].getValue());
    for (int i = 1; i < hdrs.length; i++)
    {
      valueBuffer.append(", ");
      valueBuffer.append(hdrs[i].getValue());
    }
    return new BasicHeader(name.toLowerCase(Locale.ENGLISH), valueBuffer.toString());
  }
  
  public Header[] getHeaders(String name)
  {
    List<Header> headersFound = new ArrayList();
    for (int i = 0; i < headers.size(); i++)
    {
      Header header = (Header)headers.get(i);
      if (header.getName().equalsIgnoreCase(name)) {
        headersFound.add(header);
      }
    }
    return (Header[])headersFound.toArray(new Header[headersFound.size()]);
  }
  
  public Header getFirstHeader(String name)
  {
    for (int i = 0; i < headers.size(); i++)
    {
      Header header = (Header)headers.get(i);
      if (header.getName().equalsIgnoreCase(name)) {
        return header;
      }
    }
    return null;
  }
  
  public Header getLastHeader(String name)
  {
    for (int i = headers.size() - 1; i >= 0; i--)
    {
      Header header = (Header)headers.get(i);
      if (header.getName().equalsIgnoreCase(name)) {
        return header;
      }
    }
    return null;
  }
  
  public Header[] getAllHeaders()
  {
    return (Header[])headers.toArray(new Header[headers.size()]);
  }
  
  public boolean containsHeader(String name)
  {
    for (int i = 0; i < headers.size(); i++)
    {
      Header header = (Header)headers.get(i);
      if (header.getName().equalsIgnoreCase(name)) {
        return true;
      }
    }
    return false;
  }
  
  public HeaderIterator iterator()
  {
    return new BasicListHeaderIterator(headers, null);
  }
  
  public HeaderIterator iterator(String name)
  {
    return new BasicListHeaderIterator(headers, name);
  }
  
  public HeaderGroup copy()
  {
    HeaderGroup clone = new HeaderGroup();
    headers.addAll(headers);
    return clone;
  }
  
  public Object clone()
    throws CloneNotSupportedException
  {
    return super.clone();
  }
  
  public String toString()
  {
    return headers.toString();
  }
}

/* Location:
 * Qualified Name:     org.apache.http.message.HeaderGroup
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.apache.http.message;

import org.apache.http.HeaderElement;
import org.apache.http.NameValuePair;
import org.apache.http.util.CharArrayBuffer;

public abstract interface HeaderValueFormatter
{
  public abstract CharArrayBuffer formatElements(CharArrayBuffer paramCharArrayBuffer, HeaderElement[] paramArrayOfHeaderElement, boolean paramBoolean);
  
  public abstract CharArrayBuffer formatHeaderElement(CharArrayBuffer paramCharArrayBuffer, HeaderElement paramHeaderElement, boolean paramBoolean);
  
  public abstract CharArrayBuffer formatParameters(CharArrayBuffer paramCharArrayBuffer, NameValuePair[] paramArrayOfNameValuePair, boolean paramBoolean);
  
  public abstract CharArrayBuffer formatNameValuePair(CharArrayBuffer paramCharArrayBuffer, NameValuePair paramNameValuePair, boolean paramBoolean);
}

/* Location:
 * Qualified Name:     org.apache.http.message.HeaderValueFormatter
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.apache.http.message;

import org.apache.http.HeaderElement;
import org.apache.http.NameValuePair;
import org.apache.http.ParseException;
import org.apache.http.util.CharArrayBuffer;

public abstract interface HeaderValueParser
{
  public abstract HeaderElement[] parseElements(CharArrayBuffer paramCharArrayBuffer, ParserCursor paramParserCursor)
    throws ParseException;
  
  public abstract HeaderElement parseHeaderElement(CharArrayBuffer paramCharArrayBuffer, ParserCursor paramParserCursor)
    throws ParseException;
  
  public abstract NameValuePair[] parseParameters(CharArrayBuffer paramCharArrayBuffer, ParserCursor paramParserCursor)
    throws ParseException;
  
  public abstract NameValuePair parseNameValuePair(CharArrayBuffer paramCharArrayBuffer, ParserCursor paramParserCursor)
    throws ParseException;
}

/* Location:
 * Qualified Name:     org.apache.http.message.HeaderValueParser
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.apache.http.message;

import org.apache.http.Header;
import org.apache.http.ProtocolVersion;
import org.apache.http.RequestLine;
import org.apache.http.StatusLine;
import org.apache.http.util.CharArrayBuffer;

public abstract interface LineFormatter
{
  public abstract CharArrayBuffer appendProtocolVersion(CharArrayBuffer paramCharArrayBuffer, ProtocolVersion paramProtocolVersion);
  
  public abstract CharArrayBuffer formatRequestLine(CharArrayBuffer paramCharArrayBuffer, RequestLine paramRequestLine);
  
  public abstract CharArrayBuffer formatStatusLine(CharArrayBuffer paramCharArrayBuffer, StatusLine paramStatusLine);
  
  public abstract CharArrayBuffer formatHeader(CharArrayBuffer paramCharArrayBuffer, Header paramHeader);
}

/* Location:
 * Qualified Name:     org.apache.http.message.LineFormatter
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.apache.http.message;

import org.apache.http.Header;
import org.apache.http.ParseException;
import org.apache.http.ProtocolVersion;
import org.apache.http.RequestLine;
import org.apache.http.StatusLine;
import org.apache.http.util.CharArrayBuffer;

public abstract interface LineParser
{
  public abstract ProtocolVersion parseProtocolVersion(CharArrayBuffer paramCharArrayBuffer, ParserCursor paramParserCursor)
    throws ParseException;
  
  public abstract boolean hasProtocolVersion(CharArrayBuffer paramCharArrayBuffer, ParserCursor paramParserCursor);
  
  public abstract RequestLine parseRequestLine(CharArrayBuffer paramCharArrayBuffer, ParserCursor paramParserCursor)
    throws ParseException;
  
  public abstract StatusLine parseStatusLine(CharArrayBuffer paramCharArrayBuffer, ParserCursor paramParserCursor)
    throws ParseException;
  
  public abstract Header parseHeader(CharArrayBuffer paramCharArrayBuffer)
    throws ParseException;
}

/* Location:
 * Qualified Name:     org.apache.http.message.LineParser
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.apache.http.message;

import org.apache.http.annotation.NotThreadSafe;

@NotThreadSafe
public class ParserCursor
{
  private final int lowerBound;
  private final int upperBound;
  private int pos;
  
  public ParserCursor(int lowerBound, int upperBound)
  {
    if (lowerBound < 0) {
      throw new IndexOutOfBoundsException("Lower bound cannot be negative");
    }
    if (lowerBound > upperBound) {
      throw new IndexOutOfBoundsException("Lower bound cannot be greater then upper bound");
    }
    this.lowerBound = lowerBound;
    this.upperBound = upperBound;
    pos = lowerBound;
  }
  
  public int getLowerBound()
  {
    return lowerBound;
  }
  
  public int getUpperBound()
  {
    return upperBound;
  }
  
  public int getPos()
  {
    return pos;
  }
  
  public void updatePos(int pos)
  {
    if (pos < lowerBound) {
      throw new IndexOutOfBoundsException("pos: " + pos + " < lowerBound: " + lowerBound);
    }
    if (pos > upperBound) {
      throw new IndexOutOfBoundsException("pos: " + pos + " > upperBound: " + upperBound);
    }
    this.pos = pos;
  }
  
  public boolean atEnd()
  {
    return pos >= upperBound;
  }
  
  public String toString()
  {
    StringBuilder buffer = new StringBuilder();
    buffer.append('[');
    buffer.append(Integer.toString(lowerBound));
    buffer.append('>');
    buffer.append(Integer.toString(pos));
    buffer.append('>');
    buffer.append(Integer.toString(upperBound));
    buffer.append(']');
    return buffer.toString();
  }
}

/* Location:
 * Qualified Name:     org.apache.http.message.ParserCursor
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.apache.http.params;

import java.util.Set;

@Deprecated
public abstract class AbstractHttpParams
  implements HttpParams, HttpParamsNames
{
  public long getLongParameter(String name, long defaultValue)
  {
    Object param = getParameter(name);
    if (param == null) {
      return defaultValue;
    }
    return ((Long)param).longValue();
  }
  
  public HttpParams setLongParameter(String name, long value)
  {
    setParameter(name, Long.valueOf(value));
    return this;
  }
  
  public int getIntParameter(String name, int defaultValue)
  {
    Object param = getParameter(name);
    if (param == null) {
      return defaultValue;
    }
    return ((Integer)param).intValue();
  }
  
  public HttpParams setIntParameter(String name, int value)
  {
    setParameter(name, Integer.valueOf(value));
    return this;
  }
  
  public double getDoubleParameter(String name, double defaultValue)
  {
    Object param = getParameter(name);
    if (param == null) {
      return defaultValue;
    }
    return ((Double)param).doubleValue();
  }
  
  public HttpParams setDoubleParameter(String name, double value)
  {
    setParameter(name, Double.valueOf(value));
    return this;
  }
  
  public boolean getBooleanParameter(String name, boolean defaultValue)
  {
    Object param = getParameter(name);
    if (param == null) {
      return defaultValue;
    }
    return ((Boolean)param).booleanValue();
  }
  
  public HttpParams setBooleanParameter(String name, boolean value)
  {
    setParameter(name, value ? Boolean.TRUE : Boolean.FALSE);
    return this;
  }
  
  public boolean isParameterTrue(String name)
  {
    return getBooleanParameter(name, false);
  }
  
  public boolean isParameterFalse(String name)
  {
    return !getBooleanParameter(name, false);
  }
  
  public Set<String> getNames()
  {
    throw new UnsupportedOperationException();
  }
}

/* Location:
 * Qualified Name:     org.apache.http.params.AbstractHttpParams
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.apache.http.params;

import java.io.Serializable;
import java.util.HashSet;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import org.apache.http.annotation.ThreadSafe;

@Deprecated
@ThreadSafe
public class BasicHttpParams
  extends AbstractHttpParams
  implements Serializable, Cloneable
{
  private static final long serialVersionUID = -7086398485908701455L;
  private final Map<String, Object> parameters = new ConcurrentHashMap();
  
  public Object getParameter(String name)
  {
    return parameters.get(name);
  }
  
  public HttpParams setParameter(String name, Object value)
  {
    if (name == null) {
      return this;
    }
    if (value != null) {
      parameters.put(name, value);
    } else {
      parameters.remove(name);
    }
    return this;
  }
  
  public boolean removeParameter(String name)
  {
    if (parameters.containsKey(name))
    {
      parameters.remove(name);
      return true;
    }
    return false;
  }
  
  public void setParameters(String[] names, Object value)
  {
    for (String name : names) {
      setParameter(name, value);
    }
  }
  
  public boolean isParameterSet(String name)
  {
    return getParameter(name) != null;
  }
  
  public boolean isParameterSetLocally(String name)
  {
    return parameters.get(name) != null;
  }
  
  public void clear()
  {
    parameters.clear();
  }
  
  public HttpParams copy()
  {
    try
    {
      return (HttpParams)clone();
    }
    catch (CloneNotSupportedException ex)
    {
      throw new UnsupportedOperationException("Cloning not supported");
    }
  }
  
  public Object clone()
    throws CloneNotSupportedException
  {
    BasicHttpParams clone = (BasicHttpParams)super.clone();
    copyParams(clone);
    return clone;
  }
  
  public void copyParams(HttpParams target)
  {
    for (Map.Entry<String, Object> me : parameters.entrySet()) {
      target.setParameter((String)me.getKey(), me.getValue());
    }
  }
  
  public Set<String> getNames()
  {
    return new HashSet(parameters.keySet());
  }
}

/* Location:
 * Qualified Name:     org.apache.http.params.BasicHttpParams
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.apache.http.params;

@Deprecated
public abstract interface CoreConnectionPNames
{
  public static final String SO_TIMEOUT = "http.socket.timeout";
  public static final String TCP_NODELAY = "http.tcp.nodelay";
  public static final String SOCKET_BUFFER_SIZE = "http.socket.buffer-size";
  public static final String SO_LINGER = "http.socket.linger";
  public static final String SO_REUSEADDR = "http.socket.reuseaddr";
  public static final String CONNECTION_TIMEOUT = "http.connection.timeout";
  public static final String STALE_CONNECTION_CHECK = "http.connection.stalecheck";
  public static final String MAX_LINE_LENGTH = "http.connection.max-line-length";
  public static final String MAX_HEADER_COUNT = "http.connection.max-header-count";
  public static final String MIN_CHUNK_LIMIT = "http.connection.min-chunk-limit";
  public static final String SO_KEEPALIVE = "http.socket.keepalive";
}

/* Location:
 * Qualified Name:     org.apache.http.params.CoreConnectionPNames
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.apache.http.params;

@Deprecated
public abstract interface CoreProtocolPNames
{
  public static final String PROTOCOL_VERSION = "http.protocol.version";
  public static final String HTTP_ELEMENT_CHARSET = "http.protocol.element-charset";
  public static final String HTTP_CONTENT_CHARSET = "http.protocol.content-charset";
  public static final String USER_AGENT = "http.useragent";
  public static final String ORIGIN_SERVER = "http.origin-server";
  public static final String STRICT_TRANSFER_ENCODING = "http.protocol.strict-transfer-encoding";
  public static final String USE_EXPECT_CONTINUE = "http.protocol.expect-continue";
  public static final String WAIT_FOR_CONTINUE = "http.protocol.wait-for-continue";
  public static final String HTTP_MALFORMED_INPUT_ACTION = "http.malformed.input.action";
  public static final String HTTP_UNMAPPABLE_INPUT_ACTION = "http.unmappable.input.action";
}

/* Location:
 * Qualified Name:     org.apache.http.params.CoreProtocolPNames
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.apache.http.params;

import java.util.HashSet;
import java.util.Set;
import org.apache.http.util.Args;

@Deprecated
public final class DefaultedHttpParams
  extends AbstractHttpParams
{
  private final HttpParams local;
  private final HttpParams defaults;
  
  public DefaultedHttpParams(HttpParams local, HttpParams defaults)
  {
    this.local = ((HttpParams)Args.notNull(local, "Local HTTP parameters"));
    this.defaults = defaults;
  }
  
  public HttpParams copy()
  {
    HttpParams clone = local.copy();
    return new DefaultedHttpParams(clone, defaults);
  }
  
  public Object getParameter(String name)
  {
    Object obj = local.getParameter(name);
    if ((obj == null) && (defaults != null)) {
      obj = defaults.getParameter(name);
    }
    return obj;
  }
  
  public boolean removeParameter(String name)
  {
    return local.removeParameter(name);
  }
  
  public HttpParams setParameter(String name, Object value)
  {
    return local.setParameter(name, value);
  }
  
  public HttpParams getDefaults()
  {
    return defaults;
  }
  
  public Set<String> getNames()
  {
    Set<String> combined = new HashSet(getNames(defaults));
    combined.addAll(getNames(local));
    return combined;
  }
  
  public Set<String> getDefaultNames()
  {
    return new HashSet(getNames(defaults));
  }
  
  public Set<String> getLocalNames()
  {
    return new HashSet(getNames(local));
  }
  
  private Set<String> getNames(HttpParams params)
  {
    if ((params instanceof HttpParamsNames)) {
      return ((HttpParamsNames)params).getNames();
    }
    throw new UnsupportedOperationException("HttpParams instance does not implement HttpParamsNames");
  }
}

/* Location:
 * Qualified Name:     org.apache.http.params.DefaultedHttpParams
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.apache.http.params;

import org.apache.http.util.Args;

@Deprecated
public abstract class HttpAbstractParamBean
{
  protected final HttpParams params;
  
  public HttpAbstractParamBean(HttpParams params)
  {
    this.params = ((HttpParams)Args.notNull(params, "HTTP parameters"));
  }
}

/* Location:
 * Qualified Name:     org.apache.http.params.HttpAbstractParamBean
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.apache.http.params;

@Deprecated
public class HttpConnectionParamBean
  extends HttpAbstractParamBean
{
  public HttpConnectionParamBean(HttpParams params)
  {
    super(params);
  }
  
  public void setSoTimeout(int soTimeout)
  {
    HttpConnectionParams.setSoTimeout(params, soTimeout);
  }
  
  public void setTcpNoDelay(boolean tcpNoDelay)
  {
    HttpConnectionParams.setTcpNoDelay(params, tcpNoDelay);
  }
  
  public void setSocketBufferSize(int socketBufferSize)
  {
    HttpConnectionParams.setSocketBufferSize(params, socketBufferSize);
  }
  
  public void setLinger(int linger)
  {
    HttpConnectionParams.setLinger(params, linger);
  }
  
  public void setConnectionTimeout(int connectionTimeout)
  {
    HttpConnectionParams.setConnectionTimeout(params, connectionTimeout);
  }
  
  public void setStaleCheckingEnabled(boolean staleCheckingEnabled)
  {
    HttpConnectionParams.setStaleCheckingEnabled(params, staleCheckingEnabled);
  }
}

/* Location:
 * Qualified Name:     org.apache.http.params.HttpConnectionParamBean
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.apache.http.params;

import org.apache.http.util.Args;

@Deprecated
public final class HttpConnectionParams
  implements CoreConnectionPNames
{
  public static int getSoTimeout(HttpParams params)
  {
    Args.notNull(params, "HTTP parameters");
    return params.getIntParameter("http.socket.timeout", 0);
  }
  
  public static void setSoTimeout(HttpParams params, int timeout)
  {
    Args.notNull(params, "HTTP parameters");
    params.setIntParameter("http.socket.timeout", timeout);
  }
  
  public static boolean getSoReuseaddr(HttpParams params)
  {
    Args.notNull(params, "HTTP parameters");
    return params.getBooleanParameter("http.socket.reuseaddr", false);
  }
  
  public static void setSoReuseaddr(HttpParams params, boolean reuseaddr)
  {
    Args.notNull(params, "HTTP parameters");
    params.setBooleanParameter("http.socket.reuseaddr", reuseaddr);
  }
  
  public static boolean getTcpNoDelay(HttpParams params)
  {
    Args.notNull(params, "HTTP parameters");
    return params.getBooleanParameter("http.tcp.nodelay", true);
  }
  
  public static void setTcpNoDelay(HttpParams params, boolean value)
  {
    Args.notNull(params, "HTTP parameters");
    params.setBooleanParameter("http.tcp.nodelay", value);
  }
  
  public static int getSocketBufferSize(HttpParams params)
  {
    Args.notNull(params, "HTTP parameters");
    return params.getIntParameter("http.socket.buffer-size", -1);
  }
  
  public static void setSocketBufferSize(HttpParams params, int size)
  {
    Args.notNull(params, "HTTP parameters");
    params.setIntParameter("http.socket.buffer-size", size);
  }
  
  public static int getLinger(HttpParams params)
  {
    Args.notNull(params, "HTTP parameters");
    return params.getIntParameter("http.socket.linger", -1);
  }
  
  public static void setLinger(HttpParams params, int value)
  {
    Args.notNull(params, "HTTP parameters");
    params.setIntParameter("http.socket.linger", value);
  }
  
  public static int getConnectionTimeout(HttpParams params)
  {
    Args.notNull(params, "HTTP parameters");
    return params.getIntParameter("http.connection.timeout", 0);
  }
  
  public static void setConnectionTimeout(HttpParams params, int timeout)
  {
    Args.notNull(params, "HTTP parameters");
    params.setIntParameter("http.connection.timeout", timeout);
  }
  
  public static boolean isStaleCheckingEnabled(HttpParams params)
  {
    Args.notNull(params, "HTTP parameters");
    return params.getBooleanParameter("http.connection.stalecheck", true);
  }
  
  public static void setStaleCheckingEnabled(HttpParams params, boolean value)
  {
    Args.notNull(params, "HTTP parameters");
    params.setBooleanParameter("http.connection.stalecheck", value);
  }
  
  public static boolean getSoKeepalive(HttpParams params)
  {
    Args.notNull(params, "HTTP parameters");
    return params.getBooleanParameter("http.socket.keepalive", false);
  }
  
  public static void setSoKeepalive(HttpParams params, boolean enableKeepalive)
  {
    Args.notNull(params, "HTTP parameters");
    params.setBooleanParameter("http.socket.keepalive", enableKeepalive);
  }
}

/* Location:
 * Qualified Name:     org.apache.http.params.HttpConnectionParams
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.apache.http.params;

import java.nio.charset.Charset;
import java.nio.charset.CodingErrorAction;
import org.apache.http.config.ConnectionConfig;
import org.apache.http.config.ConnectionConfig.Builder;
import org.apache.http.config.MessageConstraints;
import org.apache.http.config.MessageConstraints.Builder;
import org.apache.http.config.SocketConfig;
import org.apache.http.config.SocketConfig.Builder;

@Deprecated
public final class HttpParamConfig
{
  public static SocketConfig getSocketConfig(HttpParams params)
  {
    return SocketConfig.custom().setSoTimeout(params.getIntParameter("http.socket.timeout", 0)).setSoReuseAddress(params.getBooleanParameter("http.socket.reuseaddr", false)).setSoKeepAlive(params.getBooleanParameter("http.socket.keepalive", false)).setSoLinger(params.getIntParameter("http.socket.linger", -1)).setTcpNoDelay(params.getBooleanParameter("http.tcp.nodelay", true)).build();
  }
  
  public static MessageConstraints getMessageConstraints(HttpParams params)
  {
    return MessageConstraints.custom().setMaxHeaderCount(params.getIntParameter("http.connection.max-header-count", -1)).setMaxLineLength(params.getIntParameter("http.connection.max-line-length", -1)).build();
  }
  
  public static ConnectionConfig getConnectionConfig(HttpParams params)
  {
    MessageConstraints messageConstraints = getMessageConstraints(params);
    String csname = (String)params.getParameter("http.protocol.element-charset");
    return ConnectionConfig.custom().setCharset(csname != null ? Charset.forName(csname) : null).setMalformedInputAction((CodingErrorAction)params.getParameter("http.malformed.input.action")).setMalformedInputAction((CodingErrorAction)params.getParameter("http.unmappable.input.action")).setMessageConstraints(messageConstraints).build();
  }
}

/* Location:
 * Qualified Name:     org.apache.http.params.HttpParamConfig
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.apache.http.params;

@Deprecated
public abstract interface HttpParams
{
  public abstract Object getParameter(String paramString);
  
  public abstract HttpParams setParameter(String paramString, Object paramObject);
  
  public abstract HttpParams copy();
  
  public abstract boolean removeParameter(String paramString);
  
  public abstract long getLongParameter(String paramString, long paramLong);
  
  public abstract HttpParams setLongParameter(String paramString, long paramLong);
  
  public abstract int getIntParameter(String paramString, int paramInt);
  
  public abstract HttpParams setIntParameter(String paramString, int paramInt);
  
  public abstract double getDoubleParameter(String paramString, double paramDouble);
  
  public abstract HttpParams setDoubleParameter(String paramString, double paramDouble);
  
  public abstract boolean getBooleanParameter(String paramString, boolean paramBoolean);
  
  public abstract HttpParams setBooleanParameter(String paramString, boolean paramBoolean);
  
  public abstract boolean isParameterTrue(String paramString);
  
  public abstract boolean isParameterFalse(String paramString);
}

/* Location:
 * Qualified Name:     org.apache.http.params.HttpParams
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.apache.http.params;

import java.util.Set;

@Deprecated
public abstract interface HttpParamsNames
{
  public abstract Set<String> getNames();
}

/* Location:
 * Qualified Name:     org.apache.http.params.HttpParamsNames
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.apache.http.params;

import org.apache.http.HttpVersion;

@Deprecated
public class HttpProtocolParamBean
  extends HttpAbstractParamBean
{
  public HttpProtocolParamBean(HttpParams params)
  {
    super(params);
  }
  
  public void setHttpElementCharset(String httpElementCharset)
  {
    HttpProtocolParams.setHttpElementCharset(params, httpElementCharset);
  }
  
  public void setContentCharset(String contentCharset)
  {
    HttpProtocolParams.setContentCharset(params, contentCharset);
  }
  
  public void setVersion(HttpVersion version)
  {
    HttpProtocolParams.setVersion(params, version);
  }
  
  public void setUserAgent(String userAgent)
  {
    HttpProtocolParams.setUserAgent(params, userAgent);
  }
  
  public void setUseExpectContinue(boolean useExpectContinue)
  {
    HttpProtocolParams.setUseExpectContinue(params, useExpectContinue);
  }
}

/* Location:
 * Qualified Name:     org.apache.http.params.HttpProtocolParamBean
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.apache.http.params;

import java.nio.charset.Charset;
import java.nio.charset.CodingErrorAction;
import org.apache.http.HttpVersion;
import org.apache.http.ProtocolVersion;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.Args;

@Deprecated
public final class HttpProtocolParams
  implements CoreProtocolPNames
{
  public static String getHttpElementCharset(HttpParams params)
  {
    Args.notNull(params, "HTTP parameters");
    String charset = (String)params.getParameter("http.protocol.element-charset");
    if (charset == null) {
      charset = HTTP.DEF_PROTOCOL_CHARSET.name();
    }
    return charset;
  }
  
  public static void setHttpElementCharset(HttpParams params, String charset)
  {
    Args.notNull(params, "HTTP parameters");
    params.setParameter("http.protocol.element-charset", charset);
  }
  
  public static String getContentCharset(HttpParams params)
  {
    Args.notNull(params, "HTTP parameters");
    String charset = (String)params.getParameter("http.protocol.content-charset");
    if (charset == null) {
      charset = HTTP.DEF_CONTENT_CHARSET.name();
    }
    return charset;
  }
  
  public static void setContentCharset(HttpParams params, String charset)
  {
    Args.notNull(params, "HTTP parameters");
    params.setParameter("http.protocol.content-charset", charset);
  }
  
  public static ProtocolVersion getVersion(HttpParams params)
  {
    Args.notNull(params, "HTTP parameters");
    Object param = params.getParameter("http.protocol.version");
    if (param == null) {
      return HttpVersion.HTTP_1_1;
    }
    return (ProtocolVersion)param;
  }
  
  public static void setVersion(HttpParams params, ProtocolVersion version)
  {
    Args.notNull(params, "HTTP parameters");
    params.setParameter("http.protocol.version", version);
  }
  
  public static String getUserAgent(HttpParams params)
  {
    Args.notNull(params, "HTTP parameters");
    return (String)params.getParameter("http.useragent");
  }
  
  public static void setUserAgent(HttpParams params, String useragent)
  {
    Args.notNull(params, "HTTP parameters");
    params.setParameter("http.useragent", useragent);
  }
  
  public static boolean useExpectContinue(HttpParams params)
  {
    Args.notNull(params, "HTTP parameters");
    return params.getBooleanParameter("http.protocol.expect-continue", false);
  }
  
  public static void setUseExpectContinue(HttpParams params, boolean b)
  {
    Args.notNull(params, "HTTP parameters");
    params.setBooleanParameter("http.protocol.expect-continue", b);
  }
  
  public static CodingErrorAction getMalformedInputAction(HttpParams params)
  {
    Args.notNull(params, "HTTP parameters");
    Object param = params.getParameter("http.malformed.input.action");
    if (param == null) {
      return CodingErrorAction.REPORT;
    }
    return (CodingErrorAction)param;
  }
  
  public static void setMalformedInputAction(HttpParams params, CodingErrorAction action)
  {
    Args.notNull(params, "HTTP parameters");
    params.setParameter("http.malformed.input.action", action);
  }
  
  public static CodingErrorAction getUnmappableInputAction(HttpParams params)
  {
    Args.notNull(params, "HTTP parameters");
    Object param = params.getParameter("http.unmappable.input.action");
    if (param == null) {
      return CodingErrorAction.REPORT;
    }
    return (CodingErrorAction)param;
  }
  
  public static void setUnmappableInputAction(HttpParams params, CodingErrorAction action)
  {
    Args.notNull(params, "HTTP parameters");
    params.setParameter("http.unmappable.input.action", action);
  }
}

/* Location:
 * Qualified Name:     org.apache.http.params.HttpProtocolParams
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.apache.http.params;

import org.apache.http.annotation.ThreadSafe;

@Deprecated
@ThreadSafe
public class SyncBasicHttpParams
  extends BasicHttpParams
{
  private static final long serialVersionUID = 5387834869062660642L;
  
  public synchronized boolean removeParameter(String name)
  {
    return super.removeParameter(name);
  }
  
  public synchronized HttpParams setParameter(String name, Object value)
  {
    return super.setParameter(name, value);
  }
  
  public synchronized Object getParameter(String name)
  {
    return super.getParameter(name);
  }
  
  public synchronized boolean isParameterSet(String name)
  {
    return super.isParameterSet(name);
  }
  
  public synchronized boolean isParameterSetLocally(String name)
  {
    return super.isParameterSetLocally(name);
  }
  
  public synchronized void setParameters(String[] names, Object value)
  {
    super.setParameters(names, value);
  }
  
  public synchronized void clear()
  {
    super.clear();
  }
  
  public synchronized Object clone()
    throws CloneNotSupportedException
  {
    return super.clone();
  }
}

/* Location:
 * Qualified Name:     org.apache.http.params.SyncBasicHttpParams
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.apache.http.pool;

class AbstractConnPool$1
  extends RouteSpecificPool<T, C, E>
{
  AbstractConnPool$1(AbstractConnPool paramAbstractConnPool, Object x0, Object paramObject1)
  {
    super(x0);
  }
  
  protected E createEntry(C conn)
  {
    return this$0.createEntry(val$route, conn);
  }
}

/* Location:
 * Qualified Name:     org.apache.http.pool.AbstractConnPool.1
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.apache.http.pool;

import java.io.IOException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.locks.Lock;
import org.apache.http.concurrent.FutureCallback;

class AbstractConnPool$2
  extends PoolEntryFuture<E>
{
  AbstractConnPool$2(AbstractConnPool paramAbstractConnPool, Lock x0, FutureCallback x1, Object paramObject1, Object paramObject2)
  {
    super(x0, x1);
  }
  
  public E getPoolEntry(long timeout, TimeUnit tunit)
    throws InterruptedException, TimeoutException, IOException
  {
    E entry = AbstractConnPool.access$000(this$0, val$route, val$state, timeout, tunit, this);
    this$0.onLease(entry);
    return entry;
  }
}

/* Location:
 * Qualified Name:     org.apache.http.pool.AbstractConnPool.2
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.apache.http.pool;

class AbstractConnPool$3
  implements PoolEntryCallback<T, C>
{
  AbstractConnPool$3(AbstractConnPool paramAbstractConnPool, long paramLong) {}
  
  public void process(PoolEntry<T, C> entry)
  {
    if (entry.getUpdated() <= val$deadline) {
      entry.close();
    }
  }
}

/* Location:
 * Qualified Name:     org.apache.http.pool.AbstractConnPool.3
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.apache.http.pool;

class AbstractConnPool$4
  implements PoolEntryCallback<T, C>
{
  AbstractConnPool$4(AbstractConnPool paramAbstractConnPool, long paramLong) {}
  
  public void process(PoolEntry<T, C> entry)
  {
    if (entry.isExpired(val$now)) {
      entry.close();
    }
  }
}

/* Location:
 * Qualified Name:     org.apache.http.pool.AbstractConnPool.4
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.apache.http.pool;

import java.io.IOException;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import org.apache.http.annotation.ThreadSafe;
import org.apache.http.concurrent.FutureCallback;
import org.apache.http.util.Args;
import org.apache.http.util.Asserts;

@ThreadSafe
public abstract class AbstractConnPool<T, C, E extends PoolEntry<T, C>>
  implements ConnPool<T, E>, ConnPoolControl<T>
{
  private final Lock lock;
  private final ConnFactory<T, C> connFactory;
  private final Map<T, RouteSpecificPool<T, C, E>> routeToPool;
  private final Set<E> leased;
  private final LinkedList<E> available;
  private final LinkedList<PoolEntryFuture<E>> pending;
  private final Map<T, Integer> maxPerRoute;
  private volatile boolean isShutDown;
  private volatile int defaultMaxPerRoute;
  private volatile int maxTotal;
  
  public AbstractConnPool(ConnFactory<T, C> connFactory, int defaultMaxPerRoute, int maxTotal)
  {
    this.connFactory = ((ConnFactory)Args.notNull(connFactory, "Connection factory"));
    this.defaultMaxPerRoute = Args.notNegative(defaultMaxPerRoute, "Max per route value");
    this.maxTotal = Args.notNegative(maxTotal, "Max total value");
    lock = new ReentrantLock();
    routeToPool = new HashMap();
    leased = new HashSet();
    available = new LinkedList();
    pending = new LinkedList();
    maxPerRoute = new HashMap();
  }
  
  protected abstract E createEntry(T paramT, C paramC);
  
  protected void onLease(E entry) {}
  
  protected void onRelease(E entry) {}
  
  public boolean isShutdown()
  {
    return isShutDown;
  }
  
  public void shutdown()
    throws IOException
  {
    if (isShutDown) {
      return;
    }
    isShutDown = true;
    lock.lock();
    try
    {
      for (E entry : available) {
        entry.close();
      }
      for (E entry : leased) {
        entry.close();
      }
      for (RouteSpecificPool<T, C, E> pool : routeToPool.values()) {
        pool.shutdown();
      }
      routeToPool.clear();
      leased.clear();
      available.clear();
    }
    finally
    {
      lock.unlock();
    }
  }
  
  private RouteSpecificPool<T, C, E> getPool(final T route)
  {
    RouteSpecificPool<T, C, E> pool = (RouteSpecificPool)routeToPool.get(route);
    if (pool == null)
    {
      pool = new RouteSpecificPool(route)
      {
        protected E createEntry(C conn)
        {
          return createEntry(route, conn);
        }
      };
      routeToPool.put(route, pool);
    }
    return pool;
  }
  
  public Future<E> lease(final T route, final Object state, FutureCallback<E> callback)
  {
    Args.notNull(route, "Route");
    Asserts.check(!isShutDown, "Connection pool shut down");
    new PoolEntryFuture(lock, callback)
    {
      public E getPoolEntry(long timeout, TimeUnit tunit)
        throws InterruptedException, TimeoutException, IOException
      {
        E entry = AbstractConnPool.this.getPoolEntryBlocking(route, state, timeout, tunit, this);
        onLease(entry);
        return entry;
      }
    };
  }
  
  public Future<E> lease(T route, Object state)
  {
    return lease(route, state, null);
  }
  
  private E getPoolEntryBlocking(T route, Object state, long timeout, TimeUnit tunit, PoolEntryFuture<E> future)
    throws IOException, InterruptedException, TimeoutException
  {
    Date deadline = null;
    if (timeout > 0L) {
      deadline = new Date(System.currentTimeMillis() + tunit.toMillis(timeout));
    }
    lock.lock();
    try
    {
      RouteSpecificPool<T, C, E> pool = getPool(route);
      E entry = null;
      while (entry == null)
      {
        Asserts.check(!isShutDown, "Connection pool shut down");
        for (;;)
        {
          entry = pool.getFree(state);