ClientConnectionSettings

abstract def connectingTimeout: FiniteDuration

abstract def idleTimeout: Duration

abstract def localAddress: Option[InetSocketAddress]

abstract def logUnencryptedNetworkBytes: Option[Int]

abstract def parserSettings: ParserSettings

abstract def requestHeaderSizeHint: Int

abstract def socketOptions: Seq[SocketOption]

abstract def transport: ClientTransport

The underlying transport used to connect to hosts.

abstract def userAgentHeader: Option[User-Agent]

abstract def websocketRandomFactory: () ⇒ Random

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (ClientConnectionSettings, B)

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def ensuring(cond: (ClientConnectionSettings) ⇒ Boolean, msg: ⇒ Any): ClientConnectionSettings

def ensuring(cond: (ClientConnectionSettings) ⇒ Boolean): ClientConnectionSettings

def ensuring(cond: Boolean, msg: ⇒ Any): ClientConnectionSettings

def ensuring(cond: Boolean): ClientConnectionSettings

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def formatted(fmtstr: String): String

final def getClass(): Class[_]

final def getConnectingTimeout: FiniteDuration

final def getIdleTimeout: Duration

final def getLocalAddress: Optional[InetSocketAddress]

final def getLogUnencryptedNetworkBytes: Optional[Int]

final def getParserSettings: javadsl.settings.ParserSettings

final def getRequestHeaderSizeHint: Int

final def getSocketOptions: Iterable[SocketOption]

def getTransport: javadsl.ClientTransport

The underlying transport used to connect to hosts.

final def getUserAgentHeader: Optional[UserAgent]

final val getWebsocketRandomFactory: Supplier[Random]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withConnectingTimeout(newValue: FiniteDuration): ClientConnectionSettings

def withIdleTimeout(newValue: Duration): ClientConnectionSettings

def withLocalAddress(newValue: Option[InetSocketAddress]): ClientConnectionSettings

def withLocalAddress(newValue: Optional[InetSocketAddress]): javadsl.settings.ClientConnectionSettings

def withLocalAddressOverride(overrideLocalAddressOption: Option[InetSocketAddress]): ClientConnectionSettings

Returns a new instance with the given local address set if the given override is Some(address), otherwise return this instance unchanged.

def withLogUnencryptedNetworkBytes(newValue: Option[Int]): ClientConnectionSettings

def withLogUnencryptedNetworkBytes(newValue: Optional[Int]): javadsl.settings.ClientConnectionSettings

def withParserSettings(newValue: ParserSettings): ClientConnectionSettings

def withParserSettings(newValue: javadsl.settings.ParserSettings): javadsl.settings.ClientConnectionSettings

def withRequestHeaderSizeHint(newValue: Int): ClientConnectionSettings

def withSocketOptions(newValue: Seq[SocketOption]): ClientConnectionSettings

def withSocketOptions(newValue: Iterable[SocketOption]): javadsl.settings.ClientConnectionSettings

def withTransport(newTransport: ClientTransport): ClientConnectionSettings

def withTransport(newValue: javadsl.ClientTransport): javadsl.settings.ClientConnectionSettings

def withUserAgentHeader(newValue: Option[User-Agent]): ClientConnectionSettings

def withUserAgentHeader(newValue: Optional[UserAgent]): javadsl.settings.ClientConnectionSettings

def withWebsocketRandomFactory(newValue: () ⇒ Random): ClientConnectionSettings

def withWebsocketRandomFactory(newValue: Supplier[Random]): javadsl.settings.ClientConnectionSettings

def →[B](y: B): (ClientConnectionSettings, B)