<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>ConnectionOptions (Qpid ProtonJ2 Parent 1.0.0-M19 API)</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<meta name="description" content="declaration: package: org.apache.qpid.protonj2.client, class: ConnectionOptions">
<meta name="generator" content="javadoc/ClassWriterImpl">
<link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
<script type="text/javascript" src="../../../../../script.js"></script>
</head>
<body class="class-declaration-page">
<script type="text/javascript">var evenRowColor = "even-row-color";
var oddRowColor = "odd-row-color";
var tableTab = "table-tab";
var activeTableTab = "active-table-tab";
</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<div class="flex-box">
<header role="banner" class="flex-header">
<nav role="navigation">
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="top-nav" id="navbar-top">
<div class="skip-nav"><a href="#skip-navbar-top" title="Skip navigation links">Skip navigation links</a></div>
<ul id="navbar-top-firstrow" class="nav-list" title="Navigation">
<li><a href="../../../../../index.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="nav-bar-cell1-rev">Class</li>
<li><a href="class-use/ConnectionOptions.html">Use</a></li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../../help-doc.html#class">Help</a></li>
</ul>
</div>
<div class="sub-nav">
<div>
<ul class="sub-nav-list">
<li>Summary:&nbsp;</li>
<li>Nested&nbsp;|&nbsp;</li>
<li><a href="#field-summary">Field</a>&nbsp;|&nbsp;</li>
<li><a href="#constructor-summary">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method-summary">Method</a></li>
</ul>
<ul class="sub-nav-list">
<li>Detail:&nbsp;</li>
<li><a href="#field-detail">Field</a>&nbsp;|&nbsp;</li>
<li><a href="#constructor-detail">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method-detail">Method</a></li>
</ul>
</div>
</div>
<!-- ========= END OF TOP NAVBAR ========= -->
<span class="skip-nav" id="skip-navbar-top"></span></nav>
</header>
<div class="flex-content">
<main role="main">
<!-- ======== START OF CLASS DATA ======== -->
<div class="header">
<div class="sub-title"><span class="package-label-in-type">Package</span>&nbsp;<a href="package-summary.html">org.apache.qpid.protonj2.client</a></div>
<h1 title="Class ConnectionOptions" class="title">Class ConnectionOptions</h1>
</div>
<div class="inheritance" title="Inheritance Tree"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">java.lang.Object</a>
<div class="inheritance">org.apache.qpid.protonj2.client.ConnectionOptions</div>
</div>
<section class="class-description" id="class-description">
<dl class="notes">
<dt>All Implemented Interfaces:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Cloneable.html" title="class or interface in java.lang" class="external-link">Cloneable</a></code></dd>
</dl>
<hr>
<div class="type-signature"><span class="modifiers">public class </span><span class="element-name type-name-label">ConnectionOptions</span>
<span class="extends-implements">extends <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>
implements <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Cloneable.html" title="class or interface in java.lang" class="external-link">Cloneable</a></span></div>
<div class="block">Options that control the behavior of the <a href="Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a> created from them.</div>
</section>
<section class="summary">
<ul class="summary-list">
<!-- =========== FIELD SUMMARY =========== -->
<li>
<section class="field-summary" id="field-summary">
<h2>Field Summary</h2>
<div class="caption"><span>Fields</span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Field</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code>static final int</code></div>
<div class="col-second even-row-color"><code><a href="#DEFAULT_CHANNEL_MAX" class="member-name-link">DEFAULT_CHANNEL_MAX</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final long</code></div>
<div class="col-second odd-row-color"><code><a href="#DEFAULT_CLOSE_TIMEOUT" class="member-name-link">DEFAULT_CLOSE_TIMEOUT</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</code></div>
<div class="col-second even-row-color"><code><a href="#DEFAULT_DESIRED_CAPABILITIES" class="member-name-link">DEFAULT_DESIRED_CAPABILITIES</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final long</code></div>
<div class="col-second odd-row-color"><code><a href="#DEFAULT_DRAIN_TIMEOUT" class="member-name-link">DEFAULT_DRAIN_TIMEOUT</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final long</code></div>
<div class="col-second even-row-color"><code><a href="#DEFAULT_IDLE_TIMEOUT" class="member-name-link">DEFAULT_IDLE_TIMEOUT</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final int</code></div>
<div class="col-second odd-row-color"><code><a href="#DEFAULT_MAX_FRAME_SIZE" class="member-name-link">DEFAULT_MAX_FRAME_SIZE</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final <a href="NextReceiverPolicy.html" title="enum in org.apache.qpid.protonj2.client">NextReceiverPolicy</a></code></div>
<div class="col-second even-row-color"><code><a href="#DEFAULT_NEXT_RECEIVER_POLICY" class="member-name-link">DEFAULT_NEXT_RECEIVER_POLICY</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final long</code></div>
<div class="col-second odd-row-color"><code><a href="#DEFAULT_OPEN_TIMEOUT" class="member-name-link">DEFAULT_OPEN_TIMEOUT</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final long</code></div>
<div class="col-second even-row-color"><code><a href="#DEFAULT_REQUEST_TIMEOUT" class="member-name-link">DEFAULT_REQUEST_TIMEOUT</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final long</code></div>
<div class="col-second odd-row-color"><code><a href="#DEFAULT_SEND_TIMEOUT" class="member-name-link">DEFAULT_SEND_TIMEOUT</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final long</code></div>
<div class="col-second even-row-color"><code><a href="#INFINITE" class="member-name-link">INFINITE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
</div>
</section>
</li>
<!-- ======== CONSTRUCTOR SUMMARY ======== -->
<li>
<section class="constructor-summary" id="constructor-summary">
<h2>Constructor Summary</h2>
<div class="caption"><span>Constructors</span></div>
<div class="summary-table two-column-summary">
<div class="table-header col-first">Constructor</div>
<div class="table-header col-last">Description</div>
<div class="col-constructor-name even-row-color"><code><a href="#%3Cinit%3E()" class="member-name-link">ConnectionOptions</a>()</code></div>
<div class="col-last even-row-color">
<div class="block">Create a new <a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client"><code>ConnectionOptions</code></a> instance configured with default configuration settings.</div>
</div>
<div class="col-constructor-name odd-row-color"><code><a href="#%3Cinit%3E(org.apache.qpid.protonj2.client.ConnectionOptions)" class="member-name-link">ConnectionOptions</a><wbr>(<a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a>&nbsp;options)</code></div>
<div class="col-last odd-row-color">
<div class="block">Creates a <a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client"><code>ConnectionOptions</code></a> instance that is a copy of the given instance.</div>
</div>
</div>
</section>
</li>
<!-- ========== METHOD SUMMARY =========== -->
<li>
<section class="method-summary" id="method-summary">
<h2>Method Summary</h2>
<div id="method-summary-table">
<div class="table-tabs" role="tablist" aria-orientation="horizontal"><button id="method-summary-table-tab0" role="tab" aria-selected="true" aria-controls="method-summary-table.tabpanel" tabindex="0" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table', 3)" class="active-table-tab">All Methods</button><button id="method-summary-table-tab2" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab2', 3)" class="table-tab">Instance Methods</button><button id="method-summary-table-tab4" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab4', 3)" class="table-tab">Concrete Methods</button></div>
<div id="method-summary-table.tabpanel" role="tabpanel">
<div class="summary-table three-column-summary" aria-labelledby="method-summary-table-tab0">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Method</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#channelMax()" class="member-name-link">channelMax</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#channelMax(int)" class="member-name-link">channelMax</a><wbr>(int&nbsp;channelMax)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Configure the channel maximum value for the new <a href="Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a> created with these options.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#clone()" class="member-name-link">clone</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>long</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#closeTimeout()" class="member-name-link">closeTimeout</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#closeTimeout(long)" class="member-name-link">closeTimeout</a><wbr>(long&nbsp;closeTimeout)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Configures the timeout used when awaiting a response from the remote that a request to close
 a resource such as a <a href="Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a>, <a href="Session.html" title="interface in org.apache.qpid.protonj2.client"><code>Session</code></a>, <a href="Sender.html" title="interface in org.apache.qpid.protonj2.client"><code>Sender</code></a> or <a href="Receiver.html" title="interface in org.apache.qpid.protonj2.client"><code>Receiver</code></a> h
 as been honored.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#closeTimeout(long,java.util.concurrent.TimeUnit)" class="member-name-link">closeTimeout</a><wbr>(long&nbsp;timeout,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/TimeUnit.html" title="class or interface in java.util.concurrent" class="external-link">TimeUnit</a>&nbsp;units)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Configures the timeout used when awaiting a response from the remote that a request to close
 a resource such as a <a href="Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a>, <a href="Session.html" title="interface in org.apache.qpid.protonj2.client"><code>Session</code></a>, <a href="Sender.html" title="interface in org.apache.qpid.protonj2.client"><code>Sender</code></a> or <a href="Receiver.html" title="interface in org.apache.qpid.protonj2.client"><code>Receiver</code></a> h
 as been honored.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/function/BiConsumer.html" title="class or interface in java.util.function" class="external-link">BiConsumer</a>&lt;<a href="Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a>,<wbr><a href="ConnectionEvent.html" title="class in org.apache.qpid.protonj2.client">ConnectionEvent</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#connectedHandler()" class="member-name-link">connectedHandler</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#connectedHandler(java.util.function.BiConsumer)" class="member-name-link">connectedHandler</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/function/BiConsumer.html" title="class or interface in java.util.function" class="external-link">BiConsumer</a>&lt;<a href="Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a>,<wbr><a href="ConnectionEvent.html" title="class in org.apache.qpid.protonj2.client">ConnectionEvent</a>&gt;&nbsp;connectedHandler)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Configures a handler that will be notified when a <a href="Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a> has established.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected <a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#copyInto(org.apache.qpid.protonj2.client.ConnectionOptions)" class="member-name-link">copyInto</a><wbr>(<a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a>&nbsp;other)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Copy all options from this <a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client"><code>ConnectionOptions</code></a> instance into the instance
 provided.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="NextReceiverPolicy.html" title="enum in org.apache.qpid.protonj2.client">NextReceiverPolicy</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#defaultNextReceiverPolicy()" class="member-name-link">defaultNextReceiverPolicy</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#defaultNextReceiverPolicy(org.apache.qpid.protonj2.client.NextReceiverPolicy)" class="member-name-link">defaultNextReceiverPolicy</a><wbr>(<a href="NextReceiverPolicy.html" title="enum in org.apache.qpid.protonj2.client">NextReceiverPolicy</a>&nbsp;policy)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Configures the default next receiver policy for this connection and any session
 that is created without specifying user defined session default options.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>[]</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#desiredCapabilities()" class="member-name-link">desiredCapabilities</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#desiredCapabilities(java.lang.String...)" class="member-name-link">desiredCapabilities</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>...&nbsp;desiredCapabilities)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets the collection of capabilities to request from the remote for a new <a href="Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a>
 created using these <a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client"><code>ConnectionOptions</code></a>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/function/BiConsumer.html" title="class or interface in java.util.function" class="external-link">BiConsumer</a>&lt;<a href="Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a>,<wbr><a href="DisconnectionEvent.html" title="class in org.apache.qpid.protonj2.client">DisconnectionEvent</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#disconnectedHandler()" class="member-name-link">disconnectedHandler</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#disconnectedHandler(java.util.function.BiConsumer)" class="member-name-link">disconnectedHandler</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/function/BiConsumer.html" title="class or interface in java.util.function" class="external-link">BiConsumer</a>&lt;<a href="Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a>,<wbr><a href="DisconnectionEvent.html" title="class in org.apache.qpid.protonj2.client">DisconnectionEvent</a>&gt;&nbsp;disconnectedHandler)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Configures a handler that will be notified when the connection has failed and cannot be recovered
 should reconnect be enabled.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>long</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#drainTimeout()" class="member-name-link">drainTimeout</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#drainTimeout(long)" class="member-name-link">drainTimeout</a><wbr>(long&nbsp;drainTimeout)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets the drain timeout (in milliseconds) after which a <a href="Receiver.html" title="interface in org.apache.qpid.protonj2.client"><code>Receiver</code></a> request to drain
 link credit is considered failed and the request will be marked as such.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#drainTimeout(long,java.util.concurrent.TimeUnit)" class="member-name-link">drainTimeout</a><wbr>(long&nbsp;timeout,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/TimeUnit.html" title="class or interface in java.util.concurrent" class="external-link">TimeUnit</a>&nbsp;units)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets the drain timeout value after which a <a href="Receiver.html" title="interface in org.apache.qpid.protonj2.client"><code>Receiver</code></a> request to drain
 link credit is considered failed and the request will be marked as such.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>long</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#idleTimeout()" class="member-name-link">idleTimeout</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#idleTimeout(long)" class="member-name-link">idleTimeout</a><wbr>(long&nbsp;idleTimeout)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets the idle timeout (in milliseconds) after which the connection will
 be closed if the peer has not send any data.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#idleTimeout(long,java.util.concurrent.TimeUnit)" class="member-name-link">idleTimeout</a><wbr>(long&nbsp;timeout,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/TimeUnit.html" title="class or interface in java.util.concurrent" class="external-link">TimeUnit</a>&nbsp;units)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets the idle timeout value after which the connection will be closed
 if the peer has not send any data.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/function/BiConsumer.html" title="class or interface in java.util.function" class="external-link">BiConsumer</a>&lt;<a href="Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a>,<wbr><a href="DisconnectionEvent.html" title="class in org.apache.qpid.protonj2.client">DisconnectionEvent</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#interruptedHandler()" class="member-name-link">interruptedHandler</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#interruptedHandler(java.util.function.BiConsumer)" class="member-name-link">interruptedHandler</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/function/BiConsumer.html" title="class or interface in java.util.function" class="external-link">BiConsumer</a>&lt;<a href="Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a>,<wbr><a href="DisconnectionEvent.html" title="class in org.apache.qpid.protonj2.client">DisconnectionEvent</a>&gt;&nbsp;interruptedHandler)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Configures a handler that will be notified when the current <a href="Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a> experiences an
 interruption.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#maxFrameSize()" class="member-name-link">maxFrameSize</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#maxFrameSize(int)" class="member-name-link">maxFrameSize</a><wbr>(int&nbsp;maxFrameSize)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets the max frame size (in bytes), values of -1 indicates to use the client selected default.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>[]</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#offeredCapabilities()" class="member-name-link">offeredCapabilities</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#offeredCapabilities(java.lang.String...)" class="member-name-link">offeredCapabilities</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>...&nbsp;offeredCapabilities)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets the collection of capabilities to offer to the remote from a new <a href="Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a>
 created using these <a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client"><code>ConnectionOptions</code></a>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>long</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#openTimeout()" class="member-name-link">openTimeout</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#openTimeout(long)" class="member-name-link">openTimeout</a><wbr>(long&nbsp;openTimeout)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Configures the timeout used when awaiting a response from the remote that a request to open
 a resource such as a <a href="Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a>, <a href="Session.html" title="interface in org.apache.qpid.protonj2.client"><code>Session</code></a>, <a href="Sender.html" title="interface in org.apache.qpid.protonj2.client"><code>Sender</code></a> or <a href="Receiver.html" title="interface in org.apache.qpid.protonj2.client"><code>Receiver</code></a>
 has been honored.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#openTimeout(long,java.util.concurrent.TimeUnit)" class="member-name-link">openTimeout</a><wbr>(long&nbsp;timeout,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/TimeUnit.html" title="class or interface in java.util.concurrent" class="external-link">TimeUnit</a>&nbsp;units)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Configures the timeout used when awaiting a response from the remote that a request to open
 a resource such as a <a href="Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a>, <a href="Session.html" title="interface in org.apache.qpid.protonj2.client"><code>Session</code></a>, <a href="Sender.html" title="interface in org.apache.qpid.protonj2.client"><code>Sender</code></a> or <a href="Receiver.html" title="interface in org.apache.qpid.protonj2.client"><code>Receiver</code></a>
 has been honored.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#password()" class="member-name-link">password</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#password(java.lang.String)" class="member-name-link">password</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;password)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets the password used when performing connection authentication.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#properties()" class="member-name-link">properties</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#properties(java.util.Map)" class="member-name-link">properties</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;properties)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link"><code>Map</code></a> of properties to convey to the remote when a new <a href="Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a>
 is created from these <a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client"><code>ConnectionOptions</code></a>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/function/BiConsumer.html" title="class or interface in java.util.function" class="external-link">BiConsumer</a>&lt;<a href="Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a>,<wbr><a href="ConnectionEvent.html" title="class in org.apache.qpid.protonj2.client">ConnectionEvent</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#reconnectedHandler()" class="member-name-link">reconnectedHandler</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#reconnectedHandler(java.util.function.BiConsumer)" class="member-name-link">reconnectedHandler</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/function/BiConsumer.html" title="class or interface in java.util.function" class="external-link">BiConsumer</a>&lt;<a href="Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a>,<wbr><a href="ConnectionEvent.html" title="class in org.apache.qpid.protonj2.client">ConnectionEvent</a>&gt;&nbsp;reconnectedHandler)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Configures a handler that will be notified when a <a href="Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a> that has previously
 experienced and interruption has been reconnected to a remote based on the reconnection
 configuration.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#reconnectEnabled()" class="member-name-link">reconnectEnabled</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#reconnectEnabled(boolean)" class="member-name-link">reconnectEnabled</a><wbr>(boolean&nbsp;reconnectEnabled)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Controls if the connection will attempt to reconnect if unable to connect immediately
 or if an existing connection fails (default is disabled).</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ReconnectOptions.html" title="class in org.apache.qpid.protonj2.client">ReconnectOptions</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#reconnectOptions()" class="member-name-link">reconnectOptions</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>long</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#requestTimeout()" class="member-name-link">requestTimeout</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#requestTimeout(long)" class="member-name-link">requestTimeout</a><wbr>(long&nbsp;requestTimeout)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Configures the timeout used when awaiting a response from the remote that a request to
 perform some action such as starting a new transaction.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#requestTimeout(long,java.util.concurrent.TimeUnit)" class="member-name-link">requestTimeout</a><wbr>(long&nbsp;timeout,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/TimeUnit.html" title="class or interface in java.util.concurrent" class="external-link">TimeUnit</a>&nbsp;units)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Configures the timeout used when awaiting a response from the remote that a request to
 perform some action such as starting a new transaction.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="SaslOptions.html" title="class in org.apache.qpid.protonj2.client">SaslOptions</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#saslOptions()" class="member-name-link">saslOptions</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>long</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#sendTimeout()" class="member-name-link">sendTimeout</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#sendTimeout(long)" class="member-name-link">sendTimeout</a><wbr>(long&nbsp;sendTimeout)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Configures the timeout used when awaiting a send operation to complete.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#sendTimeout(long,java.util.concurrent.TimeUnit)" class="member-name-link">sendTimeout</a><wbr>(long&nbsp;timeout,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/TimeUnit.html" title="class or interface in java.util.concurrent" class="external-link">TimeUnit</a>&nbsp;units)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Configures the timeout used when awaiting a send operation to complete.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#sslEnabled()" class="member-name-link">sslEnabled</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#sslEnabled(boolean)" class="member-name-link">sslEnabled</a><wbr>(boolean&nbsp;sslEnabled)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Controls if the connection will attempt to connect using a secure IO layer or not.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="SslOptions.html" title="class in org.apache.qpid.protonj2.client">SslOptions</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#sslOptions()" class="member-name-link">sslOptions</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#traceFrames()" class="member-name-link">traceFrames</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#traceFrames(boolean)" class="member-name-link">traceFrames</a><wbr>(boolean&nbsp;traceFrames)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Configure if the newly created connection should enabled AMQP frame tracing to the
 system output.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="TransportOptions.html" title="class in org.apache.qpid.protonj2.client">TransportOptions</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#transportOptions()" class="member-name-link">transportOptions</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#user()" class="member-name-link">user</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#user(java.lang.String)" class="member-name-link">user</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;user)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets the user name used when performing connection authentication.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#virtualHost()" class="member-name-link">virtualHost</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#virtualHost(java.lang.String)" class="member-name-link">virtualHost</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;virtualHost)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">The virtual host value to provide to the remote when creating a new <a href="Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a>.</div>
</div>
</div>
</div>
</div>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-java.lang.Object">Methods inherited from class&nbsp;java.lang.<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></h3>
<code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#equals(java.lang.Object)" title="class or interface in java.lang" class="external-link">equals</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#finalize()" title="class or interface in java.lang" class="external-link">finalize</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#getClass()" title="class or interface in java.lang" class="external-link">getClass</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#hashCode()" title="class or interface in java.lang" class="external-link">hashCode</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#notify()" title="class or interface in java.lang" class="external-link">notify</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#notifyAll()" title="class or interface in java.lang" class="external-link">notifyAll</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#toString()" title="class or interface in java.lang" class="external-link">toString</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#wait()" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#wait(long)" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#wait(long,int)" title="class or interface in java.lang" class="external-link">wait</a></code></div>
</section>
</li>
</ul>
</section>
<section class="details">
<ul class="details-list">
<!-- ============ FIELD DETAIL =========== -->
<li>
<section class="field-details" id="field-detail">
<h2>Field Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="DEFAULT_DESIRED_CAPABILITIES">
<h3>DEFAULT_DESIRED_CAPABILITIES</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</span>&nbsp;<span class="element-name">DEFAULT_DESIRED_CAPABILITIES</span></div>
</section>
</li>
<li>
<section class="detail" id="INFINITE">
<h3>INFINITE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">INFINITE</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.qpid.protonj2.client.ConnectionOptions.INFINITE">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="DEFAULT_OPEN_TIMEOUT">
<h3>DEFAULT_OPEN_TIMEOUT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">DEFAULT_OPEN_TIMEOUT</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.qpid.protonj2.client.ConnectionOptions.DEFAULT_OPEN_TIMEOUT">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="DEFAULT_CLOSE_TIMEOUT">
<h3>DEFAULT_CLOSE_TIMEOUT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">DEFAULT_CLOSE_TIMEOUT</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.qpid.protonj2.client.ConnectionOptions.DEFAULT_CLOSE_TIMEOUT">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="DEFAULT_SEND_TIMEOUT">
<h3>DEFAULT_SEND_TIMEOUT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">DEFAULT_SEND_TIMEOUT</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.qpid.protonj2.client.ConnectionOptions.DEFAULT_SEND_TIMEOUT">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="DEFAULT_REQUEST_TIMEOUT">
<h3>DEFAULT_REQUEST_TIMEOUT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">DEFAULT_REQUEST_TIMEOUT</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.qpid.protonj2.client.ConnectionOptions.DEFAULT_REQUEST_TIMEOUT">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="DEFAULT_IDLE_TIMEOUT">
<h3>DEFAULT_IDLE_TIMEOUT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">DEFAULT_IDLE_TIMEOUT</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.qpid.protonj2.client.ConnectionOptions.DEFAULT_IDLE_TIMEOUT">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="DEFAULT_DRAIN_TIMEOUT">
<h3>DEFAULT_DRAIN_TIMEOUT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">DEFAULT_DRAIN_TIMEOUT</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.qpid.protonj2.client.ConnectionOptions.DEFAULT_DRAIN_TIMEOUT">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="DEFAULT_CHANNEL_MAX">
<h3>DEFAULT_CHANNEL_MAX</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">DEFAULT_CHANNEL_MAX</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.qpid.protonj2.client.ConnectionOptions.DEFAULT_CHANNEL_MAX">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="DEFAULT_MAX_FRAME_SIZE">
<h3>DEFAULT_MAX_FRAME_SIZE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">DEFAULT_MAX_FRAME_SIZE</span></div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.qpid.protonj2.client.ConnectionOptions.DEFAULT_MAX_FRAME_SIZE">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="DEFAULT_NEXT_RECEIVER_POLICY">
<h3>DEFAULT_NEXT_RECEIVER_POLICY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="NextReceiverPolicy.html" title="enum in org.apache.qpid.protonj2.client">NextReceiverPolicy</a></span>&nbsp;<span class="element-name">DEFAULT_NEXT_RECEIVER_POLICY</span></div>
</section>
</li>
</ul>
</section>
</li>
<!-- ========= CONSTRUCTOR DETAIL ======== -->
<li>
<section class="constructor-details" id="constructor-detail">
<h2>Constructor Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="&lt;init&gt;()">
<h3>ConnectionOptions</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="element-name">ConnectionOptions</span>()</div>
<div class="block">Create a new <a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client"><code>ConnectionOptions</code></a> instance configured with default configuration settings.</div>
</section>
</li>
<li>
<section class="detail" id="&lt;init&gt;(org.apache.qpid.protonj2.client.ConnectionOptions)">
<h3>ConnectionOptions</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="element-name">ConnectionOptions</span><wbr><span class="parameters">(<a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a>&nbsp;options)</span></div>
<div class="block">Creates a <a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client"><code>ConnectionOptions</code></a> instance that is a copy of the given instance.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>options</code> - The <a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client"><code>ConnectionOptions</code></a> instance whose configuration should be copied to this one.</dd>
</dl>
</section>
</li>
</ul>
</section>
</li>
<!-- ============ METHOD DETAIL ========== -->
<li>
<section class="method-details" id="method-detail">
<h2>Method Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="clone()">
<h3>clone</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></span>&nbsp;<span class="element-name">clone</span>()</div>
<dl class="notes">
<dt>Overrides:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#clone()" title="class or interface in java.lang" class="external-link">clone</a></code>&nbsp;in class&nbsp;<code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="copyInto(org.apache.qpid.protonj2.client.ConnectionOptions)">
<h3>copyInto</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type"><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></span>&nbsp;<span class="element-name">copyInto</span><wbr><span class="parameters">(<a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a>&nbsp;other)</span></div>
<div class="block">Copy all options from this <a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client"><code>ConnectionOptions</code></a> instance into the instance
 provided.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>other</code> - the target of this copy operation.</dd>
<dt>Returns:</dt>
<dd>the <a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client"><code>ConnectionOptions</code></a> instance that was given.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="closeTimeout()">
<h3>closeTimeout</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">closeTimeout</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the timeout used when awaiting a response from the remote when a resource is closed.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="closeTimeout(long)">
<h3>closeTimeout</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></span>&nbsp;<span class="element-name">closeTimeout</span><wbr><span class="parameters">(long&nbsp;closeTimeout)</span></div>
<div class="block">Configures the timeout used when awaiting a response from the remote that a request to close
 a resource such as a <a href="Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a>, <a href="Session.html" title="interface in org.apache.qpid.protonj2.client"><code>Session</code></a>, <a href="Sender.html" title="interface in org.apache.qpid.protonj2.client"><code>Sender</code></a> or <a href="Receiver.html" title="interface in org.apache.qpid.protonj2.client"><code>Receiver</code></a> h
 as been honored.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>closeTimeout</code> - Timeout value in milliseconds to wait for a remote response.</dd>
<dt>Returns:</dt>
<dd>this <a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client"><code>ConnectionOptions</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="closeTimeout(long,java.util.concurrent.TimeUnit)">
<h3>closeTimeout</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></span>&nbsp;<span class="element-name">closeTimeout</span><wbr><span class="parameters">(long&nbsp;timeout,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/TimeUnit.html" title="class or interface in java.util.concurrent" class="external-link">TimeUnit</a>&nbsp;units)</span></div>
<div class="block">Configures the timeout used when awaiting a response from the remote that a request to close
 a resource such as a <a href="Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a>, <a href="Session.html" title="interface in org.apache.qpid.protonj2.client"><code>Session</code></a>, <a href="Sender.html" title="interface in org.apache.qpid.protonj2.client"><code>Sender</code></a> or <a href="Receiver.html" title="interface in org.apache.qpid.protonj2.client"><code>Receiver</code></a> h
 as been honored.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>timeout</code> - Timeout value to wait for a remote response.</dd>
<dd><code>units</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/TimeUnit.html" title="class or interface in java.util.concurrent" class="external-link"><code>TimeUnit</code></a> that defines the timeout span.</dd>
<dt>Returns:</dt>
<dd>this <a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client"><code>ConnectionOptions</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="openTimeout()">
<h3>openTimeout</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">openTimeout</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the timeout used when awaiting a response from the remote when a resource is opened.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="openTimeout(long)">
<h3>openTimeout</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></span>&nbsp;<span class="element-name">openTimeout</span><wbr><span class="parameters">(long&nbsp;openTimeout)</span></div>
<div class="block">Configures the timeout used when awaiting a response from the remote that a request to open
 a resource such as a <a href="Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a>, <a href="Session.html" title="interface in org.apache.qpid.protonj2.client"><code>Session</code></a>, <a href="Sender.html" title="interface in org.apache.qpid.protonj2.client"><code>Sender</code></a> or <a href="Receiver.html" title="interface in org.apache.qpid.protonj2.client"><code>Receiver</code></a>
 has been honored.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>openTimeout</code> - Timeout value in milliseconds to wait for a remote response.</dd>
<dt>Returns:</dt>
<dd>this <a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client"><code>ConnectionOptions</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="openTimeout(long,java.util.concurrent.TimeUnit)">
<h3>openTimeout</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></span>&nbsp;<span class="element-name">openTimeout</span><wbr><span class="parameters">(long&nbsp;timeout,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/TimeUnit.html" title="class or interface in java.util.concurrent" class="external-link">TimeUnit</a>&nbsp;units)</span></div>
<div class="block">Configures the timeout used when awaiting a response from the remote that a request to open
 a resource such as a <a href="Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a>, <a href="Session.html" title="interface in org.apache.qpid.protonj2.client"><code>Session</code></a>, <a href="Sender.html" title="interface in org.apache.qpid.protonj2.client"><code>Sender</code></a> or <a href="Receiver.html" title="interface in org.apache.qpid.protonj2.client"><code>Receiver</code></a>
 has been honored.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>timeout</code> - Timeout value to wait for a remote response.</dd>
<dd><code>units</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/TimeUnit.html" title="class or interface in java.util.concurrent" class="external-link"><code>TimeUnit</code></a> that defines the timeout span.</dd>
<dt>Returns:</dt>
<dd>this <a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client"><code>ConnectionOptions</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="sendTimeout()">
<h3>sendTimeout</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">sendTimeout</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the timeout used when awaiting a response from the remote when a resource is message send.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="sendTimeout(long)">
<h3>sendTimeout</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></span>&nbsp;<span class="element-name">sendTimeout</span><wbr><span class="parameters">(long&nbsp;sendTimeout)</span></div>
<div class="block">Configures the timeout used when awaiting a send operation to complete.  A send will block if the
 remote has not granted the <a href="Sender.html" title="interface in org.apache.qpid.protonj2.client"><code>Sender</code></a> or the <a href="Session.html" title="interface in org.apache.qpid.protonj2.client"><code>Session</code></a> credit to do so, if the send blocks
 for longer than this timeout the send call will fail with an <a href="exceptions/ClientSendTimedOutException.html" title="class in org.apache.qpid.protonj2.client.exceptions"><code>ClientSendTimedOutException</code></a>
 exception to indicate that the send did not complete.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>sendTimeout</code> - Timeout value in milliseconds to wait for a remote response.</dd>
<dt>Returns:</dt>
<dd>this <a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client"><code>ConnectionOptions</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="sendTimeout(long,java.util.concurrent.TimeUnit)">
<h3>sendTimeout</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></span>&nbsp;<span class="element-name">sendTimeout</span><wbr><span class="parameters">(long&nbsp;timeout,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/TimeUnit.html" title="class or interface in java.util.concurrent" class="external-link">TimeUnit</a>&nbsp;units)</span></div>
<div class="block">Configures the timeout used when awaiting a send operation to complete.  A send will block if the
 remote has not granted the <a href="Sender.html" title="interface in org.apache.qpid.protonj2.client"><code>Sender</code></a> or the <a href="Session.html" title="interface in org.apache.qpid.protonj2.client"><code>Session</code></a> credit to do so, if the send blocks
 for longer than this timeout the send call will fail with an <a href="exceptions/ClientSendTimedOutException.html" title="class in org.apache.qpid.protonj2.client.exceptions"><code>ClientSendTimedOutException</code></a>
 exception to indicate that the send did not complete.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>timeout</code> - Timeout value to wait for a remote response.</dd>
<dd><code>units</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/TimeUnit.html" title="class or interface in java.util.concurrent" class="external-link"><code>TimeUnit</code></a> that defines the timeout span.</dd>
<dt>Returns:</dt>
<dd>this <a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client"><code>ConnectionOptions</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="requestTimeout()">
<h3>requestTimeout</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">requestTimeout</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the timeout used when awaiting a response from the remote when a resource makes a request.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="requestTimeout(long)">
<h3>requestTimeout</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></span>&nbsp;<span class="element-name">requestTimeout</span><wbr><span class="parameters">(long&nbsp;requestTimeout)</span></div>
<div class="block">Configures the timeout used when awaiting a response from the remote that a request to
 perform some action such as starting a new transaction.  If the remote does not respond
 within the configured timeout the resource making the request will mark it as failed and
 return an error to the request initiator usually in the form of a
 <a href="exceptions/ClientOperationTimedOutException.html" title="class in org.apache.qpid.protonj2.client.exceptions"><code>ClientOperationTimedOutException</code></a>.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>requestTimeout</code> - Timeout value in milliseconds to wait for a remote response.</dd>
<dt>Returns:</dt>
<dd>this <a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client"><code>ConnectionOptions</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="requestTimeout(long,java.util.concurrent.TimeUnit)">
<h3>requestTimeout</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></span>&nbsp;<span class="element-name">requestTimeout</span><wbr><span class="parameters">(long&nbsp;timeout,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/TimeUnit.html" title="class or interface in java.util.concurrent" class="external-link">TimeUnit</a>&nbsp;units)</span></div>
<div class="block">Configures the timeout used when awaiting a response from the remote that a request to
 perform some action such as starting a new transaction.  If the remote does not respond
 within the configured timeout the resource making the request will mark it as failed and
 return an error to the request initiator usually in the form of a
 <a href="exceptions/ClientOperationTimedOutException.html" title="class in org.apache.qpid.protonj2.client.exceptions"><code>ClientOperationTimedOutException</code></a>.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>timeout</code> - Timeout value to wait for a remote response.</dd>
<dd><code>units</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/TimeUnit.html" title="class or interface in java.util.concurrent" class="external-link"><code>TimeUnit</code></a> that defines the timeout span.</dd>
<dt>Returns:</dt>
<dd>this <a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client"><code>ConnectionOptions</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="channelMax()">
<h3>channelMax</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">channelMax</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the configured or default channel max value for create <a href="Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a> instances.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="channelMax(int)">
<h3>channelMax</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></span>&nbsp;<span class="element-name">channelMax</span><wbr><span class="parameters">(int&nbsp;channelMax)</span></div>
<div class="block">Configure the channel maximum value for the new <a href="Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a> created with these options.
 <p>
 The channel max value controls how many <a href="Session.html" title="interface in org.apache.qpid.protonj2.client"><code>Session</code></a> instances can be created by a given
 Connection, the default value is <i>65535</i>.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>channelMax</code> - The channel max value to assign to newly created <a href="Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a> instances.</dd>
<dt>Returns:</dt>
<dd>this <a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client"><code>ConnectionOptions</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="maxFrameSize()">
<h3>maxFrameSize</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">maxFrameSize</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the configure maximum frame size value for newly create <a href="Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a> instances.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="maxFrameSize(int)">
<h3>maxFrameSize</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></span>&nbsp;<span class="element-name">maxFrameSize</span><wbr><span class="parameters">(int&nbsp;maxFrameSize)</span></div>
<div class="block">Sets the max frame size (in bytes), values of -1 indicates to use the client selected default.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>maxFrameSize</code> - the frame size in bytes.</dd>
<dt>Returns:</dt>
<dd>this <a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client"><code>ConnectionOptions</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="idleTimeout()">
<h3>idleTimeout</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">idleTimeout</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the configured idle timeout value that will be sent to the remote.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="idleTimeout(long)">
<h3>idleTimeout</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></span>&nbsp;<span class="element-name">idleTimeout</span><wbr><span class="parameters">(long&nbsp;idleTimeout)</span></div>
<div class="block">Sets the idle timeout (in milliseconds) after which the connection will
 be closed if the peer has not send any data. The provided value will be
 halved before being transmitted as our advertised idle-timeout in the
 AMQP <a href="../types/transport/Open.html" title="class in org.apache.qpid.protonj2.types.transport"><code>Open</code></a> frame.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>idleTimeout</code> - the timeout in milliseconds.</dd>
<dt>Returns:</dt>
<dd>this <a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client"><code>ConnectionOptions</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="idleTimeout(long,java.util.concurrent.TimeUnit)">
<h3>idleTimeout</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></span>&nbsp;<span class="element-name">idleTimeout</span><wbr><span class="parameters">(long&nbsp;timeout,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/TimeUnit.html" title="class or interface in java.util.concurrent" class="external-link">TimeUnit</a>&nbsp;units)</span></div>
<div class="block">Sets the idle timeout value after which the connection will be closed
 if the peer has not send any data. The provided value will be halved before
 being transmitted as our advertised idle-timeout in the AMQP <a href="../types/transport/Open.html" title="class in org.apache.qpid.protonj2.types.transport"><code>Open</code></a> frame.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>timeout</code> - Timeout value to wait for a remote response.</dd>
<dd><code>units</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/TimeUnit.html" title="class or interface in java.util.concurrent" class="external-link"><code>TimeUnit</code></a> that defines the timeout span.</dd>
<dt>Returns:</dt>
<dd>this <a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client"><code>ConnectionOptions</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="drainTimeout()">
<h3>drainTimeout</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">drainTimeout</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the configured drain timeout value that will use to fail a pending drain request.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="drainTimeout(long)">
<h3>drainTimeout</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></span>&nbsp;<span class="element-name">drainTimeout</span><wbr><span class="parameters">(long&nbsp;drainTimeout)</span></div>
<div class="block">Sets the drain timeout (in milliseconds) after which a <a href="Receiver.html" title="interface in org.apache.qpid.protonj2.client"><code>Receiver</code></a> request to drain
 link credit is considered failed and the request will be marked as such.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>drainTimeout</code> - the drainTimeout to use for receiver links.</dd>
<dt>Returns:</dt>
<dd>this <a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client"><code>ConnectionOptions</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="drainTimeout(long,java.util.concurrent.TimeUnit)">
<h3>drainTimeout</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></span>&nbsp;<span class="element-name">drainTimeout</span><wbr><span class="parameters">(long&nbsp;timeout,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/TimeUnit.html" title="class or interface in java.util.concurrent" class="external-link">TimeUnit</a>&nbsp;units)</span></div>
<div class="block">Sets the drain timeout value after which a <a href="Receiver.html" title="interface in org.apache.qpid.protonj2.client"><code>Receiver</code></a> request to drain
 link credit is considered failed and the request will be marked as such.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>timeout</code> - Timeout value to wait for a remote response.</dd>
<dd><code>units</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/TimeUnit.html" title="class or interface in java.util.concurrent" class="external-link"><code>TimeUnit</code></a> that defines the timeout span.</dd>
<dt>Returns:</dt>
<dd>this <a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client"><code>ConnectionOptions</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="offeredCapabilities()">
<h3>offeredCapabilities</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>[]</span>&nbsp;<span class="element-name">offeredCapabilities</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the offeredCapabilities that have been configured.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="offeredCapabilities(java.lang.String...)">
<h3>offeredCapabilities</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></span>&nbsp;<span class="element-name">offeredCapabilities</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>...&nbsp;offeredCapabilities)</span></div>
<div class="block">Sets the collection of capabilities to offer to the remote from a new <a href="Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a>
 created using these <a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client"><code>ConnectionOptions</code></a>.  The offered capabilities advertise to the
 remote capabilities that this <a href="Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a> supports.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>offeredCapabilities</code> - the offeredCapabilities to set on a new <a href="Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a>.</dd>
<dt>Returns:</dt>
<dd>this <a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client"><code>ConnectionOptions</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="desiredCapabilities()">
<h3>desiredCapabilities</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>[]</span>&nbsp;<span class="element-name">desiredCapabilities</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the desiredCapabilities that have been configured.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="desiredCapabilities(java.lang.String...)">
<h3>desiredCapabilities</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></span>&nbsp;<span class="element-name">desiredCapabilities</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>...&nbsp;desiredCapabilities)</span></div>
<div class="block">Sets the collection of capabilities to request from the remote for a new <a href="Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a>
 created using these <a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client"><code>ConnectionOptions</code></a>.  The desired capabilities inform the remote
 peer of the various capabilities the new <a href="Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a> requires and the remote should
 return those that it supports in its offered capabilities.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>desiredCapabilities</code> - the desiredCapabilities to set on a new <a href="Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a>.</dd>
<dt>Returns:</dt>
<dd>this <a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client"><code>ConnectionOptions</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="properties()">
<h3>properties</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;</span>&nbsp;<span class="element-name">properties</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the properties that have been configured.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="properties(java.util.Map)">
<h3>properties</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></span>&nbsp;<span class="element-name">properties</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;properties)</span></div>
<div class="block">Sets a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link"><code>Map</code></a> of properties to convey to the remote when a new <a href="Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a>
 is created from these <a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client"><code>ConnectionOptions</code></a>.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>properties</code> - the properties to set</dd>
<dt>Returns:</dt>
<dd>this <a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client"><code>ConnectionOptions</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="virtualHost()">
<h3>virtualHost</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">virtualHost</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the virtual host value configured.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="virtualHost(java.lang.String)">
<h3>virtualHost</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></span>&nbsp;<span class="element-name">virtualHost</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;virtualHost)</span></div>
<div class="block">The virtual host value to provide to the remote when creating a new <a href="Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a>.
 <p>
 A value of <code>null</code> signifies that the client should send the host value used
 to connect to the remote in the SASLInit and Open performatives, otherwise the value
 provided is sent unless empty string is provided in which case no AMQP host value is
 sent in either the SASLInit or the Open performative allowing the remote to select from
 a configured default.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>virtualHost</code> - the virtual host to set</dd>
<dt>Returns:</dt>
<dd>this <a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client"><code>ConnectionOptions</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="user()">
<h3>user</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">user</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the user name that is configured for new <a href="Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a> instances.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="user(java.lang.String)">
<h3>user</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></span>&nbsp;<span class="element-name">user</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;user)</span></div>
<div class="block">Sets the user name used when performing connection authentication.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>user</code> - the user to set</dd>
<dt>Returns:</dt>
<dd>this <a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client"><code>ConnectionOptions</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="password()">
<h3>password</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">password</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the password that is configured for new <a href="Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a> instances.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="password(java.lang.String)">
<h3>password</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></span>&nbsp;<span class="element-name">password</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;password)</span></div>
<div class="block">Sets the password used when performing connection authentication.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>password</code> - the password to set</dd>
<dt>Returns:</dt>
<dd>this <a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client"><code>ConnectionOptions</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="transportOptions()">
<h3>transportOptions</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="TransportOptions.html" title="class in org.apache.qpid.protonj2.client">TransportOptions</a></span>&nbsp;<span class="element-name">transportOptions</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the transport options that will be used for the <a href="Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a>.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="sslOptions()">
<h3>sslOptions</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="SslOptions.html" title="class in org.apache.qpid.protonj2.client">SslOptions</a></span>&nbsp;<span class="element-name">sslOptions</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the SSL options that will be used for the <a href="Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a>.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="saslOptions()">
<h3>saslOptions</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="SaslOptions.html" title="class in org.apache.qpid.protonj2.client">SaslOptions</a></span>&nbsp;<span class="element-name">saslOptions</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the SASL options that will be used for the <a href="Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a>.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="reconnectEnabled()">
<h3>reconnectEnabled</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">reconnectEnabled</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>true if reconnection support has been enabled for this connection.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="reconnectEnabled(boolean)">
<h3>reconnectEnabled</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></span>&nbsp;<span class="element-name">reconnectEnabled</span><wbr><span class="parameters">(boolean&nbsp;reconnectEnabled)</span></div>
<div class="block">Controls if the connection will attempt to reconnect if unable to connect immediately
 or if an existing connection fails (default is disabled).
 <p>
 This option enables or disables reconnection to a remote peer after IO errors or remote
 forcibly closing the connection. To control specifics of the reconnection configuration
 for the <a href="Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a> the values must be updated in the <a href="ReconnectOptions.html" title="class in org.apache.qpid.protonj2.client"><code>ReconnectOptions</code></a>
 configuration prior to creating the connection.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>reconnectEnabled</code> - Controls if reconnection is enabled or not for the associated <a href="Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a>.</dd>
<dt>Returns:</dt>
<dd>this options instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="reconnectOptions()">
<h3>reconnectOptions</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ReconnectOptions.html" title="class in org.apache.qpid.protonj2.client">ReconnectOptions</a></span>&nbsp;<span class="element-name">reconnectOptions</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the reconnection options that will be used for the <a href="Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a>.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="traceFrames(boolean)">
<h3>traceFrames</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></span>&nbsp;<span class="element-name">traceFrames</span><wbr><span class="parameters">(boolean&nbsp;traceFrames)</span></div>
<div class="block">Configure if the newly created connection should enabled AMQP frame tracing to the
 system output.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>traceFrames</code> - true if frame tracing on this connection should be enabled.</dd>
<dt>Returns:</dt>
<dd>this <a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client"><code>ConnectionOptions</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="traceFrames()">
<h3>traceFrames</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">traceFrames</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>true if the connection is configured to perform frame tracing.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="sslEnabled()">
<h3>sslEnabled</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">sslEnabled</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>true if SSL support has been enabled for this connection.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="sslEnabled(boolean)">
<h3>sslEnabled</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></span>&nbsp;<span class="element-name">sslEnabled</span><wbr><span class="parameters">(boolean&nbsp;sslEnabled)</span></div>
<div class="block">Controls if the connection will attempt to connect using a secure IO layer or not.
 <p>
 This option enables or disables SSL encryption when connecting to a remote peer.  To
 control specifics of the SSL configuration for the <a href="Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a> the values must
 be updated in the <a href="SslOptions.html" title="class in org.apache.qpid.protonj2.client"><code>SslOptions</code></a> configuration prior to creating the connection.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>sslEnabled</code> - Is SSL encryption enabled for the <a href="Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a>.</dd>
<dt>Returns:</dt>
<dd>this <a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client"><code>ConnectionOptions</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="defaultNextReceiverPolicy()">
<h3>defaultNextReceiverPolicy</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="NextReceiverPolicy.html" title="enum in org.apache.qpid.protonj2.client">NextReceiverPolicy</a></span>&nbsp;<span class="element-name">defaultNextReceiverPolicy</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the configured default next receiver policy for the connection.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="defaultNextReceiverPolicy(org.apache.qpid.protonj2.client.NextReceiverPolicy)">
<h3>defaultNextReceiverPolicy</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></span>&nbsp;<span class="element-name">defaultNextReceiverPolicy</span><wbr><span class="parameters">(<a href="NextReceiverPolicy.html" title="enum in org.apache.qpid.protonj2.client">NextReceiverPolicy</a>&nbsp;policy)</span></div>
<div class="block">Configures the default next receiver policy for this connection and any session
 that is created without specifying user defined session default options.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>policy</code> - The next receiver policy to assign as the default.</dd>
<dt>Returns:</dt>
<dd>this <a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client"><code>ConnectionOptions</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="disconnectedHandler()">
<h3>disconnectedHandler</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/function/BiConsumer.html" title="class or interface in java.util.function" class="external-link">BiConsumer</a>&lt;<a href="Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a>,<wbr><a href="DisconnectionEvent.html" title="class in org.apache.qpid.protonj2.client">DisconnectionEvent</a>&gt;</span>&nbsp;<span class="element-name">disconnectedHandler</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the connection failed handler currently registered.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="disconnectedHandler(java.util.function.BiConsumer)">
<h3>disconnectedHandler</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></span>&nbsp;<span class="element-name">disconnectedHandler</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/function/BiConsumer.html" title="class or interface in java.util.function" class="external-link">BiConsumer</a>&lt;<a href="Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a>,<wbr><a href="DisconnectionEvent.html" title="class in org.apache.qpid.protonj2.client">DisconnectionEvent</a>&gt;&nbsp;disconnectedHandler)</span></div>
<div class="block">Configures a handler that will be notified when the connection has failed and cannot be recovered
 should reconnect be enabled.  Once notified of the failure the <a href="Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a> is no longer
 operable and the <a href="Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a> APIs will throw an exception to indicate that the connection
 has failed.  The client application should close a failed <a href="Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a> once it becomes
 aware of the failure to ensure all connection resources are cleaned up properly.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>disconnectedHandler</code> - the connection failed handler to notify when the connection fails for any reason.</dd>
<dt>Returns:</dt>
<dd>this <a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client"><code>ConnectionOptions</code></a> instance.</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><code>interruptedHandler</code></li>
<li><code>connectedHandler</code></li>
<li><code>disconnectedHandler</code></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="connectedHandler()">
<h3>connectedHandler</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/function/BiConsumer.html" title="class or interface in java.util.function" class="external-link">BiConsumer</a>&lt;<a href="Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a>,<wbr><a href="ConnectionEvent.html" title="class in org.apache.qpid.protonj2.client">ConnectionEvent</a>&gt;</span>&nbsp;<span class="element-name">connectedHandler</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the connection established handler that is currently registered</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="connectedHandler(java.util.function.BiConsumer)">
<h3>connectedHandler</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></span>&nbsp;<span class="element-name">connectedHandler</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/function/BiConsumer.html" title="class or interface in java.util.function" class="external-link">BiConsumer</a>&lt;<a href="Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a>,<wbr><a href="ConnectionEvent.html" title="class in org.apache.qpid.protonj2.client">ConnectionEvent</a>&gt;&nbsp;connectedHandler)</span></div>
<div class="block">Configures a handler that will be notified when a <a href="Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a> has established.
 This handler is called for each connection event when reconnection is enabled unless a
 <code>reconnectedHandler</code> is configured in which case this handler is only notified
 on the first connection to a remote.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>connectedHandler</code> - the connection established handler to assign to these <a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client"><code>ConnectionOptions</code></a>.</dd>
<dt>Returns:</dt>
<dd>this <a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client"><code>ConnectionOptions</code></a> instance.</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="#disconnectedHandler()"><code>disconnectedHandler()</code></a></li>
<li><code>interruptedHandler</code></li>
<li><code>reconnectedHandler</code></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="interruptedHandler()">
<h3>interruptedHandler</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/function/BiConsumer.html" title="class or interface in java.util.function" class="external-link">BiConsumer</a>&lt;<a href="Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a>,<wbr><a href="DisconnectionEvent.html" title="class in org.apache.qpid.protonj2.client">DisconnectionEvent</a>&gt;</span>&nbsp;<span class="element-name">interruptedHandler</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the connection interrupted handler that is currently registered</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="interruptedHandler(java.util.function.BiConsumer)">
<h3>interruptedHandler</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></span>&nbsp;<span class="element-name">interruptedHandler</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/function/BiConsumer.html" title="class or interface in java.util.function" class="external-link">BiConsumer</a>&lt;<a href="Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a>,<wbr><a href="DisconnectionEvent.html" title="class in org.apache.qpid.protonj2.client">DisconnectionEvent</a>&gt;&nbsp;interruptedHandler)</span></div>
<div class="block">Configures a handler that will be notified when the current <a href="Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a> experiences an
 interruption.  The <a href="Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a> will only signal this handler when the reconnection feature
 is enabled and will follow this event either with a notification that the connection has been
 restored (if a handler is registered), or with a notification that the connection has failed
 if the reconnection configuration places limits on the the number of reconnection attempts.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>interruptedHandler</code> - the connection interrupted handler to assign to these <a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client"><code>ConnectionOptions</code></a>.</dd>
<dt>Returns:</dt>
<dd>this <a href="ReconnectOptions.html" title="class in org.apache.qpid.protonj2.client"><code>ReconnectOptions</code></a> instance.</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><code>connectedHandler</code></li>
<li><code>reconnectedHandler</code></li>
<li><code>disconnectedHandler</code></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="reconnectedHandler()">
<h3>reconnectedHandler</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/function/BiConsumer.html" title="class or interface in java.util.function" class="external-link">BiConsumer</a>&lt;<a href="Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a>,<wbr><a href="ConnectionEvent.html" title="class in org.apache.qpid.protonj2.client">ConnectionEvent</a>&gt;</span>&nbsp;<span class="element-name">reconnectedHandler</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the connection restored handler that is currently registered</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="reconnectedHandler(java.util.function.BiConsumer)">
<h3>reconnectedHandler</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></span>&nbsp;<span class="element-name">reconnectedHandler</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/function/BiConsumer.html" title="class or interface in java.util.function" class="external-link">BiConsumer</a>&lt;<a href="Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a>,<wbr><a href="ConnectionEvent.html" title="class in org.apache.qpid.protonj2.client">ConnectionEvent</a>&gt;&nbsp;reconnectedHandler)</span></div>
<div class="block">Configures a handler that will be notified when a <a href="Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a> that has previously
 experienced and interruption has been reconnected to a remote based on the reconnection
 configuration.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>reconnectedHandler</code> - the connection restored handler to assign to these <a href="ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client"><code>ConnectionOptions</code></a>.</dd>
<dt>Returns:</dt>
<dd>this <a href="ReconnectOptions.html" title="class in org.apache.qpid.protonj2.client"><code>ReconnectOptions</code></a> instance.</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><code>connectedHandler</code></li>
<li><code>interruptedHandler</code></li>
<li><code>disconnectedHandler</code></li>
</ul>
</dd>
</dl>
</section>
</li>
</ul>
</section>
</li>
</ul>
</section>
<!-- ========= END OF CLASS DATA ========= -->
</main>
<footer role="contentinfo">
<hr>
<p class="legal-copy"><small>Copyright &#169; 2024 <a href="https://www.apache.org/">The Apache Software Foundation</a>. All rights reserved.</small></p>
</footer>
</div>
</div>
</body>
</html>
