ServiceFactory

abstract def apply(conn: ClientConnection): Future[Service[Req, Rep]]

Reserve the use of a given service instance.

abstract def close(deadline: Time): Future[Unit]

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def andThen[A](g: (Future[Service[Req, Rep]]) ⇒ A): (ClientConnection) ⇒ A

final def apply(): Future[Service[Req, Rep]]

Reserve the use of a given service instance using ClientConnection.nil.

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def close(after: Duration): Future[Unit]

final def close(): Future[Unit]

def compose[A](g: (A) ⇒ ClientConnection): (A) ⇒ Future[Service[Req, Rep]]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def flatMap[Req1, Rep1](f: (Service[Req, Rep]) ⇒ Future[Service[Req1, Rep1]]): ServiceFactory[Req1, Rep1]

Apply f on created services, returning the resulting Future in their stead.

final def getClass(): Class[_]

def hashCode(): Int

final def isAvailable: Boolean

Return true if and only if status is currently Status.Open.

final def isInstanceOf[T0]: Boolean

def map[Req1, Rep1](f: (Service[Req, Rep]) ⇒ Service[Req1, Rep1]): ServiceFactory[Req1, Rep1]

Map created services.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def status: Status

The current availability Status of this ServiceFactory

final def synchronized[T0](arg0: ⇒ T0): T0

final def toService: Service[Req, Rep]

Make a service that after dispatching a request on that service, releases the service.

def toString(): String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit