<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>TransportOptions (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: TransportOptions">
<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/TransportOptions.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 TransportOptions" class="title">Class TransportOptions</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.TransportOptions</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">TransportOptions</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">Encapsulates all the Transport options in one configuration object.</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 boolean</code></div>
<div class="col-second even-row-color"><code><a href="#DEFAULT_ALLOW_NATIVE_IO" class="member-name-link">DEFAULT_ALLOW_NATIVE_IO</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_CONNECT_TIMEOUT" class="member-name-link">DEFAULT_CONNECT_TIMEOUT</a></code></div>
<div class="col-last odd-row-color">&nbsp;</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_LOCAL_PORT" class="member-name-link">DEFAULT_LOCAL_PORT</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-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 odd-row-color"><code><a href="#DEFAULT_NATIVEIO_PREFERENCES" class="member-name-link">DEFAULT_NATIVEIO_PREFERENCES</a></code></div>
<div class="col-last odd-row-color">&nbsp;</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_RECEIVE_BUFFER_SIZE" class="member-name-link">DEFAULT_RECEIVE_BUFFER_SIZE</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_SEND_BUFFER_SIZE" class="member-name-link">DEFAULT_SEND_BUFFER_SIZE</a></code></div>
<div class="col-last odd-row-color">&nbsp;</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_SO_LINGER" class="member-name-link">DEFAULT_SO_LINGER</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_SO_TIMEOUT" class="member-name-link">DEFAULT_SO_TIMEOUT</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static final boolean</code></div>
<div class="col-second even-row-color"><code><a href="#DEFAULT_TCP_KEEP_ALIVE" class="member-name-link">DEFAULT_TCP_KEEP_ALIVE</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final boolean</code></div>
<div class="col-second odd-row-color"><code><a href="#DEFAULT_TCP_NO_DELAY" class="member-name-link">DEFAULT_TCP_NO_DELAY</a></code></div>
<div class="col-last odd-row-color">&nbsp;</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_TCP_PORT" class="member-name-link">DEFAULT_TCP_PORT</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final boolean</code></div>
<div class="col-second odd-row-color"><code><a href="#DEFAULT_TRACE_BYTES" class="member-name-link">DEFAULT_TRACE_BYTES</a></code></div>
<div class="col-last odd-row-color">&nbsp;</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_TRAFFIC_CLASS" class="member-name-link">DEFAULT_TRAFFIC_CLASS</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static final boolean</code></div>
<div class="col-second odd-row-color"><code><a href="#DEFAULT_USE_WEBSOCKETS" class="member-name-link">DEFAULT_USE_WEBSOCKETS</a></code></div>
<div class="col-last odd-row-color">&nbsp;</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_WEBSOCKET_MAX_FRAME_SIZE" class="member-name-link">DEFAULT_WEBSOCKET_MAX_FRAME_SIZE</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">TransportOptions</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</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><a href="TransportOptions.html" title="class in org.apache.qpid.protonj2.client">TransportOptions</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#addWebSocketHeader(java.lang.String,java.lang.String)" class="member-name-link">addWebSocketHeader</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;key,
 <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;value)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Additional headers to be passed along to the remote when performing a WebSocket based connect.</div>
</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="#allowNativeIO()" class="member-name-link">allowNativeIO</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="TransportOptions.html" title="class in org.apache.qpid.protonj2.client">TransportOptions</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#allowNativeIO(boolean)" class="member-name-link">allowNativeIO</a><wbr>(boolean&nbsp;allowNativeIO)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Determines if the a native IO implementation is preferred to the JDK based IO.</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="#clone()" class="member-name-link">clone</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>int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#connectTimeout()" class="member-name-link">connectTimeout</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="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="#connectTimeout(int)" class="member-name-link">connectTimeout</a><wbr>(int&nbsp;connectTimeout)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">A transport layer connection timeout value that controls how long a connection attempt can block
 before giving up and throwing a connection error.</div>
</div>
<div class="col-first even-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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#copyInto(org.apache.qpid.protonj2.client.TransportOptions)" class="member-name-link">copyInto</a><wbr>(<a href="TransportOptions.html" title="class in org.apache.qpid.protonj2.client">TransportOptions</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 configuration into the given <a href="TransportOptions.html" title="class in org.apache.qpid.protonj2.client"><code>TransportOptions</code></a> from this instance.</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="#defaultTcpPort()" class="member-name-link">defaultTcpPort</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="TransportOptions.html" title="class in org.apache.qpid.protonj2.client">TransportOptions</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#defaultTcpPort(int)" class="member-name-link">defaultTcpPort</a><wbr>(int&nbsp;defaultTcpPort)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">The default unsecured connection port to use when none has been specified by the user.</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="#localAddress()" class="member-name-link">localAddress</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="TransportOptions.html" title="class in org.apache.qpid.protonj2.client">TransportOptions</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#localAddress(java.lang.String)" class="member-name-link">localAddress</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;localAddress)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">The local address to bind to when attempting a remote connection.</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="#localPort()" class="member-name-link">localPort</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="TransportOptions.html" title="class in org.apache.qpid.protonj2.client">TransportOptions</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#localPort(int)" class="member-name-link">localPort</a><wbr>(int&nbsp;localPort)</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 local port value to bind to when connecting to the remote, if that port is
 already in use this can lead to a connection error.</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="#nativeIOPreference()" class="member-name-link">nativeIOPreference</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>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#nativeIOPreference(java.lang.String...)" class="member-name-link">nativeIOPreference</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;nativeIOPreference)</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>int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#receiveBufferSize()" class="member-name-link">receiveBufferSize</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="TransportOptions.html" title="class in org.apache.qpid.protonj2.client">TransportOptions</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#receiveBufferSize(int)" class="member-name-link">receiveBufferSize</a><wbr>(int&nbsp;receiveBufferSize)</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 receive buffer size in bytes, the value must be greater than zero
 or an <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/IllegalArgumentException.html" title="class or interface in java.lang" class="external-link"><code>IllegalArgumentException</code></a> will be thrown.</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="#sendBufferSize()" class="member-name-link">sendBufferSize</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="TransportOptions.html" title="class in org.apache.qpid.protonj2.client">TransportOptions</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#sendBufferSize(int)" class="member-name-link">sendBufferSize</a><wbr>(int&nbsp;sendBufferSize)</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 send buffer size in bytes, the value must be greater than zero
 or an <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/IllegalArgumentException.html" title="class or interface in java.lang" class="external-link"><code>IllegalArgumentException</code></a> will be thrown.</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="#soLinger()" class="member-name-link">soLinger</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="TransportOptions.html" title="class in org.apache.qpid.protonj2.client">TransportOptions</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#soLinger(int)" class="member-name-link">soLinger</a><wbr>(int&nbsp;soLinger)</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 soLinger value that should be configured on the connection socket.</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="#soTimeout()" class="member-name-link">soTimeout</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="TransportOptions.html" title="class in org.apache.qpid.protonj2.client">TransportOptions</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#soTimeout(int)" class="member-name-link">soTimeout</a><wbr>(int&nbsp;soTimeout)</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 value to use when configuring the socket level soTimeout option.</div>
</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="#tcpKeepAlive()" class="member-name-link">tcpKeepAlive</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="TransportOptions.html" title="class in org.apache.qpid.protonj2.client">TransportOptions</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#tcpKeepAlive(boolean)" class="member-name-link">tcpKeepAlive</a><wbr>(boolean&nbsp;keepAlive)</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 TCP socket keep-alive value that should be used for a connection.</div>
</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="#tcpNoDelay()" class="member-name-link">tcpNoDelay</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="TransportOptions.html" title="class in org.apache.qpid.protonj2.client">TransportOptions</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#tcpNoDelay(boolean)" class="member-name-link">tcpNoDelay</a><wbr>(boolean&nbsp;tcpNoDelay)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Configure the underlying connection to use the tcpNoDelay option.</div>
</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="#traceBytes()" class="member-name-link">traceBytes</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="TransportOptions.html" title="class in org.apache.qpid.protonj2.client">TransportOptions</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#traceBytes(boolean)" class="member-name-link">traceBytes</a><wbr>(boolean&nbsp;traceBytes)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Determines if the transport should add a logger for bytes in / out</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="#trafficClass()" class="member-name-link">trafficClass</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="TransportOptions.html" title="class in org.apache.qpid.protonj2.client">TransportOptions</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#trafficClass(int)" class="member-name-link">trafficClass</a><wbr>(int&nbsp;trafficClass)</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 traffic class value used by the TCP connection, valid
 range is between 0 and 255.</div>
</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="#useWebSockets()" class="member-name-link">useWebSockets</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="TransportOptions.html" title="class in org.apache.qpid.protonj2.client">TransportOptions</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#useWebSockets(boolean)" class="member-name-link">useWebSockets</a><wbr>(boolean&nbsp;webSockets)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Set to true to configure the transport layer as a WebSocket based connection.</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/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/String.html" title="class or interface in java.lang" class="external-link">String</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="#webSocketHeaders()" class="member-name-link">webSocketHeaders</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>int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#webSocketMaxFrameSize()" class="member-name-link">webSocketMaxFrameSize</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="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="#webSocketMaxFrameSize(int)" class="member-name-link">webSocketMaxFrameSize</a><wbr>(int&nbsp;maxFrameSize)</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 maximum size of each WebSocket frame, payloads larger than the max frame size are
 split into multiple frames during transmission.</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="#webSocketPath()" class="member-name-link">webSocketPath</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="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="#webSocketPath(java.lang.String)" class="member-name-link">webSocketPath</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;webSocketPath)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">The optional path element to provide when connecting via a WebSocket.</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_SEND_BUFFER_SIZE">
<h3>DEFAULT_SEND_BUFFER_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_SEND_BUFFER_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.TransportOptions.DEFAULT_SEND_BUFFER_SIZE">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="DEFAULT_RECEIVE_BUFFER_SIZE">
<h3>DEFAULT_RECEIVE_BUFFER_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_RECEIVE_BUFFER_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.TransportOptions.DEFAULT_RECEIVE_BUFFER_SIZE">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="DEFAULT_TRAFFIC_CLASS">
<h3>DEFAULT_TRAFFIC_CLASS</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_TRAFFIC_CLASS</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.TransportOptions.DEFAULT_TRAFFIC_CLASS">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="DEFAULT_TCP_NO_DELAY">
<h3>DEFAULT_TCP_NO_DELAY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">DEFAULT_TCP_NO_DELAY</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.TransportOptions.DEFAULT_TCP_NO_DELAY">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="DEFAULT_TCP_KEEP_ALIVE">
<h3>DEFAULT_TCP_KEEP_ALIVE</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">DEFAULT_TCP_KEEP_ALIVE</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.TransportOptions.DEFAULT_TCP_KEEP_ALIVE">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="DEFAULT_SO_LINGER">
<h3>DEFAULT_SO_LINGER</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_SO_LINGER</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.TransportOptions.DEFAULT_SO_LINGER">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="DEFAULT_SO_TIMEOUT">
<h3>DEFAULT_SO_TIMEOUT</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_SO_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.TransportOptions.DEFAULT_SO_TIMEOUT">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="DEFAULT_CONNECT_TIMEOUT">
<h3>DEFAULT_CONNECT_TIMEOUT</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_CONNECT_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.TransportOptions.DEFAULT_CONNECT_TIMEOUT">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="DEFAULT_TCP_PORT">
<h3>DEFAULT_TCP_PORT</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_TCP_PORT</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.TransportOptions.DEFAULT_TCP_PORT">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="DEFAULT_ALLOW_NATIVE_IO">
<h3>DEFAULT_ALLOW_NATIVE_IO</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">DEFAULT_ALLOW_NATIVE_IO</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.TransportOptions.DEFAULT_ALLOW_NATIVE_IO">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="DEFAULT_TRACE_BYTES">
<h3>DEFAULT_TRACE_BYTES</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">DEFAULT_TRACE_BYTES</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.TransportOptions.DEFAULT_TRACE_BYTES">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="DEFAULT_LOCAL_PORT">
<h3>DEFAULT_LOCAL_PORT</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_LOCAL_PORT</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.TransportOptions.DEFAULT_LOCAL_PORT">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="DEFAULT_USE_WEBSOCKETS">
<h3>DEFAULT_USE_WEBSOCKETS</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">DEFAULT_USE_WEBSOCKETS</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.TransportOptions.DEFAULT_USE_WEBSOCKETS">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="DEFAULT_WEBSOCKET_MAX_FRAME_SIZE">
<h3>DEFAULT_WEBSOCKET_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_WEBSOCKET_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.TransportOptions.DEFAULT_WEBSOCKET_MAX_FRAME_SIZE">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="DEFAULT_NATIVEIO_PREFERENCES">
<h3>DEFAULT_NATIVEIO_PREFERENCES</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_NATIVEIO_PREFERENCES</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>TransportOptions</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="element-name">TransportOptions</span>()</div>
</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="TransportOptions.html" title="class in org.apache.qpid.protonj2.client">TransportOptions</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="sendBufferSize()">
<h3>sendBufferSize</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">sendBufferSize</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the currently set send buffer size in bytes.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="sendBufferSize(int)">
<h3>sendBufferSize</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">sendBufferSize</span><wbr><span class="parameters">(int&nbsp;sendBufferSize)</span></div>
<div class="block">Sets the send buffer size in bytes, the value must be greater than zero
 or an <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/IllegalArgumentException.html" title="class or interface in java.lang" class="external-link"><code>IllegalArgumentException</code></a> will be thrown.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>sendBufferSize</code> - the new send buffer size for the TCP Transport.</dd>
<dt>Returns:</dt>
<dd>this options instance.</dd>
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/IllegalArgumentException.html" title="class or interface in java.lang" class="external-link">IllegalArgumentException</a></code> - if the value given is not in the valid range.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="receiveBufferSize()">
<h3>receiveBufferSize</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">receiveBufferSize</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the currently configured receive buffer size in bytes.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="receiveBufferSize(int)">
<h3>receiveBufferSize</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">receiveBufferSize</span><wbr><span class="parameters">(int&nbsp;receiveBufferSize)</span></div>
<div class="block">Sets the receive buffer size in bytes, the value must be greater than zero
 or an <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/IllegalArgumentException.html" title="class or interface in java.lang" class="external-link"><code>IllegalArgumentException</code></a> will be thrown.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>receiveBufferSize</code> - the new receive buffer size for the TCP Transport.</dd>
<dt>Returns:</dt>
<dd>this options instance.</dd>
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/IllegalArgumentException.html" title="class or interface in java.lang" class="external-link">IllegalArgumentException</a></code> - if the value given is not in the valid range.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="trafficClass()">
<h3>trafficClass</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">trafficClass</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the currently configured traffic class value.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="trafficClass(int)">
<h3>trafficClass</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">trafficClass</span><wbr><span class="parameters">(int&nbsp;trafficClass)</span></div>
<div class="block">Sets the traffic class value used by the TCP connection, valid
 range is between 0 and 255.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>trafficClass</code> - the new traffic class value.</dd>
<dt>Returns:</dt>
<dd>this options instance.</dd>
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/IllegalArgumentException.html" title="class or interface in java.lang" class="external-link">IllegalArgumentException</a></code> - if the value given is not in the valid range.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="soTimeout()">
<h3>soTimeout</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">soTimeout</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the configured value for the socket level soTimeout option.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="soTimeout(int)">
<h3>soTimeout</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">soTimeout</span><wbr><span class="parameters">(int&nbsp;soTimeout)</span></div>
<div class="block">Sets the value to use when configuring the socket level soTimeout option.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>soTimeout</code> - the soTimeout value to configure on the newly create socket.</dd>
<dt>Returns:</dt>
<dd>this <a href="TransportOptions.html" title="class in org.apache.qpid.protonj2.client"><code>TransportOptions</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="tcpNoDelay()">
<h3>tcpNoDelay</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">tcpNoDelay</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the configured value for the socket level tcpNoDelay option.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="tcpNoDelay(boolean)">
<h3>tcpNoDelay</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">tcpNoDelay</span><wbr><span class="parameters">(boolean&nbsp;tcpNoDelay)</span></div>
<div class="block">Configure the underlying connection to use the tcpNoDelay option.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>tcpNoDelay</code> - controls if the underlying connection configures tcpNoDelay.</dd>
<dt>Returns:</dt>
<dd>this <a href="TransportOptions.html" title="class in org.apache.qpid.protonj2.client"><code>TransportOptions</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="soLinger()">
<h3>soLinger</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">soLinger</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the configured value for the socket level soLinger option.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="soLinger(int)">
<h3>soLinger</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">soLinger</span><wbr><span class="parameters">(int&nbsp;soLinger)</span></div>
<div class="block">Configures the soLinger value that should be configured on the connection socket.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>soLinger</code> - The soLinger value to use for the underlying socket.</dd>
<dt>Returns:</dt>
<dd>this <a href="TransportOptions.html" title="class in org.apache.qpid.protonj2.client"><code>TransportOptions</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="tcpKeepAlive()">
<h3>tcpKeepAlive</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">tcpKeepAlive</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the configured value for the socket level tcpKeepAlive option.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="tcpKeepAlive(boolean)">
<h3>tcpKeepAlive</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">tcpKeepAlive</span><wbr><span class="parameters">(boolean&nbsp;keepAlive)</span></div>
<div class="block">Configures the TCP socket keep-alive value that should be used for a connection.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>keepAlive</code> - The TCP/IP keep-alive value to use for the connection.</dd>
<dt>Returns:</dt>
<dd>this <a href="TransportOptions.html" title="class in org.apache.qpid.protonj2.client"><code>TransportOptions</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="connectTimeout()">
<h3>connectTimeout</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">connectTimeout</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the configured value for the socket level connection timeout option.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="connectTimeout(int)">
<h3>connectTimeout</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">connectTimeout</span><wbr><span class="parameters">(int&nbsp;connectTimeout)</span></div>
<div class="block">A transport layer connection timeout value that controls how long a connection attempt can block
 before giving up and throwing a connection error.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>connectTimeout</code> - connection timeout in milliseconds.</dd>
<dt>Returns:</dt>
<dd>this <a href="TransportOptions.html" title="class in org.apache.qpid.protonj2.client"><code>TransportOptions</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="defaultTcpPort()">
<h3>defaultTcpPort</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">defaultTcpPort</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the configured value for the socket level default port to use for connection if none is provided.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="defaultTcpPort(int)">
<h3>defaultTcpPort</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">defaultTcpPort</span><wbr><span class="parameters">(int&nbsp;defaultTcpPort)</span></div>
<div class="block">The default unsecured connection port to use when none has been specified by the user.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>defaultTcpPort</code> - the default port to use for non-SSL connection if none provided.</dd>
<dt>Returns:</dt>
<dd>this <a href="TransportOptions.html" title="class in org.apache.qpid.protonj2.client"><code>TransportOptions</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="localAddress()">
<h3>localAddress</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">localAddress</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the configured value for the socket level localAddress option.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="localAddress(java.lang.String)">
<h3>localAddress</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">localAddress</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;localAddress)</span></div>
<div class="block">The local address to bind to when attempting a remote connection.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>localAddress</code> - the local address to bind to.</dd>
<dt>Returns:</dt>
<dd>this <a href="TransportOptions.html" title="class in org.apache.qpid.protonj2.client"><code>TransportOptions</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="localPort()">
<h3>localPort</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">localPort</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the configured value for the socket level localPort option.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="localPort(int)">
<h3>localPort</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">localPort</span><wbr><span class="parameters">(int&nbsp;localPort)</span></div>
<div class="block">Configures the local port value to bind to when connecting to the remote, if that port is
 already in use this can lead to a connection error.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>localPort</code> - local port value to use when making a remote connection.</dd>
<dt>Returns:</dt>
<dd>this <a href="TransportOptions.html" title="class in org.apache.qpid.protonj2.client"><code>TransportOptions</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="allowNativeIO()">
<h3>allowNativeIO</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">allowNativeIO</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>true if an native IO library can be used if available on this platform instead of the JDK IO.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="allowNativeIO(boolean)">
<h3>allowNativeIO</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">allowNativeIO</span><wbr><span class="parameters">(boolean&nbsp;allowNativeIO)</span></div>
<div class="block">Determines if the a native IO implementation is preferred to the JDK based IO.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>allowNativeIO</code> - should use of available native transport be allowed if one is available.</dd>
<dt>Returns:</dt>
<dd>this <a href="TransportOptions.html" title="class in org.apache.qpid.protonj2.client"><code>TransportOptions</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="nativeIOPreference()">
<h3>nativeIOPreference</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">nativeIOPreference</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the nativeIOPreference</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="nativeIOPreference(java.lang.String...)">
<h3>nativeIOPreference</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">nativeIOPreference</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;nativeIOPreference)</span></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>nativeIOPreference</code> - the nativeIOPreference to set</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="traceBytes()">
<h3>traceBytes</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">traceBytes</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>true if the transport should enable byte tracing</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="traceBytes(boolean)">
<h3>traceBytes</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">traceBytes</span><wbr><span class="parameters">(boolean&nbsp;traceBytes)</span></div>
<div class="block">Determines if the transport should add a logger for bytes in / out</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>traceBytes</code> - should the transport log the bytes in and out.</dd>
<dt>Returns:</dt>
<dd>this <a href="TransportOptions.html" title="class in org.apache.qpid.protonj2.client"><code>TransportOptions</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="useWebSockets()">
<h3>useWebSockets</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">useWebSockets</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the configured state of WebSockets for client connections.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="useWebSockets(boolean)">
<h3>useWebSockets</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">useWebSockets</span><wbr><span class="parameters">(boolean&nbsp;webSockets)</span></div>
<div class="block">Set to true to configure the transport layer as a WebSocket based connection.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>webSockets</code> - should the transport attempt connection using a WebSocket.</dd>
<dt>Returns:</dt>
<dd>this <a href="TransportOptions.html" title="class in org.apache.qpid.protonj2.client"><code>TransportOptions</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="webSocketPath()">
<h3>webSocketPath</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">webSocketPath</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the configured value for the socket level WebSocket path option.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="webSocketPath(java.lang.String)">
<h3>webSocketPath</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">webSocketPath</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;webSocketPath)</span></div>
<div class="block">The optional path element to provide when connecting via a WebSocket.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>webSocketPath</code> - path value to use for WebSocket connections.</dd>
<dt>Returns:</dt>
<dd>this <a href="TransportOptions.html" title="class in org.apache.qpid.protonj2.client"><code>TransportOptions</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="webSocketHeaders()">
<h3>webSocketHeaders</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/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</span>&nbsp;<span class="element-name">webSocketHeaders</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the configured value for the socket level WebSocket Headers option.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="addWebSocketHeader(java.lang.String,java.lang.String)">
<h3>addWebSocketHeader</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">addWebSocketHeader</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;key,
 <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;value)</span></div>
<div class="block">Additional headers to be passed along to the remote when performing a WebSocket based connect.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>key</code> - the header key to use with the provided value.</dd>
<dd><code>value</code> - the value to store under the provided key.</dd>
<dt>Returns:</dt>
<dd>this <a href="TransportOptions.html" title="class in org.apache.qpid.protonj2.client"><code>TransportOptions</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="webSocketMaxFrameSize()">
<h3>webSocketMaxFrameSize</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">webSocketMaxFrameSize</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the configured value for the socket level WebSocket max frame size option.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="webSocketMaxFrameSize(int)">
<h3>webSocketMaxFrameSize</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">webSocketMaxFrameSize</span><wbr><span class="parameters">(int&nbsp;maxFrameSize)</span></div>
<div class="block">Configures the maximum size of each WebSocket frame, payloads larger than the max frame size are
 split into multiple frames during transmission.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>maxFrameSize</code> - the maximum WebSocket frame size before payloads are split.</dd>
<dt>Returns:</dt>
<dd>this <a href="TransportOptions.html" title="class in org.apache.qpid.protonj2.client"><code>TransportOptions</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="copyInto(org.apache.qpid.protonj2.client.TransportOptions)">
<h3>copyInto</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">copyInto</span><wbr><span class="parameters">(<a href="TransportOptions.html" title="class in org.apache.qpid.protonj2.client">TransportOptions</a>&nbsp;other)</span></div>
<div class="block">Copy all configuration into the given <a href="TransportOptions.html" title="class in org.apache.qpid.protonj2.client"><code>TransportOptions</code></a> from this instance.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>other</code> - another <a href="TransportOptions.html" title="class in org.apache.qpid.protonj2.client"><code>TransportOptions</code></a> instance that will receive the configuration from this instance.</dd>
<dt>Returns:</dt>
<dd>the options instance that was copied into.</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>
