## org.apache.http.impl.conn
Class AbstractPoolEntry

    java.lang.Object
      org.apache.http.impl.conn.AbstractPoolEntry

Direct Known Subclasses:
  BasicPoolEntry, SingleClientConnManager.PoolEntry

    @NotThreadSafe
    public abstract class AbstractPoolEntry

extends Object

A pool entry for use by connection manager implementations. Pool entries work in conjunction with an `adapter`. The adapter is handed out to applications that obtain a connection. The pool entry stores the underlying connection and tracks the `route` established. The adapter delegates methods for establishing the route to its pool entry.

If the managed connections is released or revoked, the adapter gets disconnected, but the pool entry still contains the underlying connection and the established route.

Since:
  4.0

Field Summary
`protected OperatedClientConnection` `connection` The underlying connection being pooled or used.
`protected ClientConnectionOperator` `connOperator` The connection operator.
`protected HttpRoute` `route` The route for which this entry gets allocated.
`protected Object` `state` Connection state object
`protected RouteTracker` `tracker` The tracked route, or `null` before tracking starts.

Constructor Summary
`protected` `AbstractPoolEntry(ClientConnectionOperator connOperator, HttpRoute route)` Creates a new pool entry.

Method Summary
`Object` `getState()` Returns the state object associated with this pool entry.
`void` `layerProtocol(HttpContext context, HttpParams params)` Layers a protocol on top of an established tunnel.
`void` `open(HttpRoute route, HttpContext context, HttpParams params)` Opens the underlying connection.
`void` `setState(Object state)` Assigns a state object to this pool entry.
`protected void` `shutdownEntry()` Shuts down the entry.
`void` `tunnelProxy(HttpHost next, boolean secure, HttpParams params)` Tracks tunnelling of the connection to a chained proxy.
`void` `tunnelTarget(boolean secure, HttpParams params)` Tracks tunnelling of the connection to the target.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### connOperator

    protected final ClientConnectionOperator connOperator

  The connection operator.

### connection

    protected final OperatedClientConnection connection

  The underlying connection being pooled or used.

### route

    protected volatile HttpRoute route

  The route for which this entry gets allocated.

### state

    protected volatile Object state

  Connection state object

### tracker

    protected volatile RouteTracker tracker

  The tracked route, or `null` before tracking starts.

Constructor Detail

### AbstractPoolEntry

    protected AbstractPoolEntry(ClientConnectionOperator connOperator,
                                HttpRoute route)

  Creates a new pool entry.

  Parameters:
    `connOperator` - the Connection Operator for this entry
    `route` - the planned route for the connection, or `null`

Method Detail

### getState

    public Object getState()

  Returns the state object associated with this pool entry.

  Returns:
    The state object

### setState

    public void setState(Object state)

  Assigns a state object to this pool entry.

  Parameters:
    `state` - The state object

### open

    public void open(HttpRoute route,
                     HttpContext context,
                     HttpParams params)
              throws IOException

  Opens the underlying connection.

  Parameters:
    `route` - the route along which to open the connection
    `context` - the context for opening the connection
    `params` - the parameters for opening the connection
  Throws:
    `IOException` - in case of a problem

### tunnelTarget

    public void tunnelTarget(boolean secure,
                             HttpParams params)
                      throws IOException

  Tracks tunnelling of the connection to the target. The tunnel has to be established outside by sending a CONNECT request to the (last) proxy.

  Parameters:
    `secure` - `true` if the tunnel should be considered secure, `false` otherwise
    `params` - the parameters for tunnelling the connection
  Throws:
    `IOException` - in case of a problem

### tunnelProxy

    public void tunnelProxy(HttpHost next,
                            boolean secure,
                            HttpParams params)
                     throws IOException

  Tracks tunnelling of the connection to a chained proxy. The tunnel has to be established outside by sending a CONNECT request to the previous proxy.

  Parameters:
    `next` - the proxy to which the tunnel was established. See `ManagedClientConnection.tunnelProxy` for details.
    `secure` - `true` if the tunnel should be considered secure, `false` otherwise
    `params` - the parameters for tunnelling the connection
  Throws:
    `IOException` - in case of a problem

### layerProtocol

    public void layerProtocol(HttpContext context,
                              HttpParams params)
                       throws IOException

  Layers a protocol on top of an established tunnel.

  Parameters:
    `context` - the context for layering
    `params` - the parameters for layering
  Throws:
    `IOException` - in case of a problem

### shutdownEntry

    protected void shutdownEntry()

  Shuts down the entry. If `open(HttpRoute, HttpContext, HttpParams)` is in progress, this will cause that open to possibly throw an `IOException`.

Copyright © 1999-2011 The Apache Software Foundation. All Rights Reserved.