if filter.Direction != "outbound" {
			for _, c := range wl.Connections.Inbound {
				fmt.Fprintf(w, "%v\tInbound\t%v\t%v\t%v\n", name, lookupIP(c.ActualDst), lookupIP(c.Src), c.OriginalDst)
			}
		}
		if filter.Direction != "inbound" {
			for _, c := range wl.Connections.Outbound {

		m.byProxy[k] = connections
	}
	connections[conn.ID()] = conn
}

// Disconnect tracks disconnect events of ads clients.
// Returns false once there are no more connections for the given proxy.
func (m *adsConnections) Disconnect(conn connection) bool {
	m.Lock()
	defer m.Unlock()

	k := makeProxyKey(conn.Proxy())
	connections := m.byProxy[k]
	if connections == nil {
		return false
	}

    }

    /**
     * Adds a new incoming connection.
     */
    public ConnectionState add(RemoteConnection<InterHubMessage> connection) {
        EndPointQueue queue = outgoingQueue.newEndpoint();
        ConnectionState state = new ConnectionState(this, connection, queue);
        connections.add(state);
        return state;
    }

    /**

    }

    GraphConnections<N, V> connectionsU = nodeConnections.get(nodeU);
    if (connectionsU == null) {
      connectionsU = addNodeInternal(nodeU);
    }
    V previousValue = connectionsU.addSuccessor(nodeV, value);
    GraphConnections<N, V> connectionsV = nodeConnections.get(nodeV);
    if (connectionsV == null) {
      connectionsV = addNodeInternal(nodeV);
    }

    }

    GraphConnections<N, V> connectionsU = nodeConnections.get(nodeU);
    if (connectionsU == null) {
      connectionsU = addNodeInternal(nodeU);
    }
    V previousValue = connectionsU.addSuccessor(nodeV, value);
    GraphConnections<N, V> connectionsV = nodeConnections.get(nodeV);
    if (connectionsV == null) {
      connectionsV = addNodeInternal(nodeV);
    }

      }
    }
    return null
  }

  fun put(connection: RealConnection) {
    connection.lock.assertHeld()

    connections.add(connection)
//    connection.queueEvent { connectionListener.connectEnd(connection) }
    scheduleCloser()
  }

  /**
   * Notify this pool that [connection] has become idle. Returns true if the connection has been
   * removed from the pool and should be closed.

 * avoiding these options entirely, this class allows a connection to be attempted with modern
 * options and then retried without them should the attempt fail.
 *
 * ## Connection Reuse
 *
 * Each connection can carry a varying number of streams, depending on the underlying protocol being
 * used. HTTP/1.x connections can carry either zero or one streams. HTTP/2 connections can carry any

    @Override
    public void connectionClosed(ProjectConnection connection) {
        synchronized (connections) {
            connections.remove(connection);
        }
    }

    @Override
    public void disconnect() {
        synchronized (connections) {
            stopped = true;
            for (DefaultProjectConnection connection : connections) {
                connection.disconnect();
            }

    final IncomingQueue incomingQueue = new IncomingQueue(lock)
    final OutgoingQueue outgoingQueue = new OutgoingQueue(incomingQueue, lock)
    final ConnectionSet connections = new ConnectionSet(incomingQueue, outgoingQueue)

    def "discards queued outgoing messages when stop requested and no connections"() {
        def channel = new ChannelIdentifier("channel")
        def outgoingMessage = new ChannelMessage(channel, "payload")

        given:

import okhttp3.internal.concurrent.TaskRunner
import okhttp3.internal.connection.FastFallbackExchangeFinder
import okhttp3.internal.connection.ForceConnectRoutePlanner
import okhttp3.internal.connection.RealConnectionPool
import okhttp3.internal.connection.RealRoutePlanner
import okhttp3.internal.connection.RouteDatabase

/**
 * Manages reuse of HTTP and HTTP/2 connections for reduced network latency. HTTP requests that