<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>ProtonConnection (Qpid ProtonJ2 Parent 1.0.0-M18 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.engine.impl, class: ProtonConnection">
<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/ProtonConnection.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>Constr&nbsp;|&nbsp;</li>
<li><a href="#method-summary">Method</a></li>
</ul>
<ul class="sub-nav-list">
<li>Detail:&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li>Constr&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.engine.impl</a></div>
<h1 title="Class ProtonConnection" class="title">Class ProtonConnection</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"><a href="ProtonEndpoint.html" title="class in org.apache.qpid.protonj2.engine.impl">org.apache.qpid.protonj2.engine.impl.ProtonEndpoint</a>&lt;<a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a>&gt;
<div class="inheritance">org.apache.qpid.protonj2.engine.impl.ProtonConnection</div>
</div>
</div>
<section class="class-description" id="class-description">
<dl class="notes">
<dt>All Implemented Interfaces:</dt>
<dd><code><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code>, <code><a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine">Endpoint</a>&lt;<a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a>&gt;</code>, <code><a href="../../types/transport/AMQPHeader.HeaderHandler.html" title="interface in org.apache.qpid.protonj2.types.transport">AMQPHeader.HeaderHandler</a>&lt;<a href="ProtonEngine.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonEngine</a>&gt;</code>, <code><a href="../../types/transport/Performative.PerformativeHandler.html" title="interface in org.apache.qpid.protonj2.types.transport">Performative.PerformativeHandler</a>&lt;<a href="ProtonEngine.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonEngine</a>&gt;</code></dd>
</dl>
<hr>
<div class="type-signature"><span class="modifiers">public class </span><span class="element-name type-name-label">ProtonConnection</span>
<span class="extends-implements">extends <a href="ProtonEndpoint.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonEndpoint</a>&lt;<a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a>&gt;
implements <a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a>, <a href="../../types/transport/AMQPHeader.HeaderHandler.html" title="interface in org.apache.qpid.protonj2.types.transport">AMQPHeader.HeaderHandler</a>&lt;<a href="ProtonEngine.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonEngine</a>&gt;, <a href="../../types/transport/Performative.PerformativeHandler.html" title="interface in org.apache.qpid.protonj2.types.transport">Performative.PerformativeHandler</a>&lt;<a href="ProtonEngine.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonEngine</a>&gt;</span></div>
<div class="block">Implements the proton Connection API</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="inherited-list">
<h3 id="fields-inherited-from-class-org.apache.qpid.protonj2.engine.impl.ProtonEndpoint">Fields inherited from class&nbsp;org.apache.qpid.protonj2.engine.impl.<a href="ProtonEndpoint.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonEndpoint</a></h3>
<code><a href="ProtonEndpoint.html#engine">engine</a></code></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="ProtonConnection.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonConnection</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#close()" class="member-name-link">close</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Close the end point locally and send the closing performative immediately if possible or
 holds it until the Connection / Engine state allows it.</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="#getChannelMax()" class="member-name-link">getChannelMax</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="#getContainerId()" class="member-name-link">getContainerId</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="../../types/Symbol.html" title="class in org.apache.qpid.protonj2.types">Symbol</a>[]</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getDesiredCapabilities()" class="member-name-link">getDesiredCapabilities</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="#getHostname()" class="member-name-link">getHostname</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="#getIdleTimeout()" class="member-name-link">getIdleTimeout</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>long</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getMaxFrameSize()" class="member-name-link">getMaxFrameSize</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="../../types/Symbol.html" title="class in org.apache.qpid.protonj2.types">Symbol</a>[]</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getOfferedCapabilities()" class="member-name-link">getOfferedCapabilities</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="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getParent()" class="member-name-link">getParent</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Gets the parent of this <a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a> which can be itself for <a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine"><code>Connection</code></a> instance.</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="../../types/Symbol.html" title="class in org.apache.qpid.protonj2.types">Symbol</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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getProperties()" class="member-name-link">getProperties</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="#getRemoteContainerId()" class="member-name-link">getRemoteContainerId</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="../../types/Symbol.html" title="class in org.apache.qpid.protonj2.types">Symbol</a>[]</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getRemoteDesiredCapabilities()" class="member-name-link">getRemoteDesiredCapabilities</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="#getRemoteHostname()" class="member-name-link">getRemoteHostname</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="#getRemoteIdleTimeout()" class="member-name-link">getRemoteIdleTimeout</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>long</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getRemoteMaxFrameSize()" class="member-name-link">getRemoteMaxFrameSize</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="../../types/Symbol.html" title="class in org.apache.qpid.protonj2.types">Symbol</a>[]</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getRemoteOfferedCapabilities()" class="member-name-link">getRemoteOfferedCapabilities</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/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="../../types/Symbol.html" title="class in org.apache.qpid.protonj2.types">Symbol</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="#getRemoteProperties()" class="member-name-link">getRemoteProperties</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="../ConnectionState.html" title="enum in org.apache.qpid.protonj2.engine">ConnectionState</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getRemoteState()" class="member-name-link">getRemoteState</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="../ConnectionState.html" title="enum in org.apache.qpid.protonj2.engine">ConnectionState</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getState()" class="member-name-link">getState</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>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#handleAMQPHeader(org.apache.qpid.protonj2.types.transport.AMQPHeader,org.apache.qpid.protonj2.engine.impl.ProtonEngine)" class="member-name-link">handleAMQPHeader</a><wbr>(<a href="../../types/transport/AMQPHeader.html" title="class in org.apache.qpid.protonj2.types.transport">AMQPHeader</a>&nbsp;header,
 <a href="ProtonEngine.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonEngine</a>&nbsp;context)</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="#handleAttach(org.apache.qpid.protonj2.types.transport.Attach,org.apache.qpid.protonj2.buffer.ProtonBuffer,int,org.apache.qpid.protonj2.engine.impl.ProtonEngine)" class="member-name-link">handleAttach</a><wbr>(<a href="../../types/transport/Attach.html" title="class in org.apache.qpid.protonj2.types.transport">Attach</a>&nbsp;attach,
 <a href="../../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;payload,
 int&nbsp;channel,
 <a href="ProtonEngine.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonEngine</a>&nbsp;context)</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>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#handleBegin(org.apache.qpid.protonj2.types.transport.Begin,org.apache.qpid.protonj2.buffer.ProtonBuffer,int,org.apache.qpid.protonj2.engine.impl.ProtonEngine)" class="member-name-link">handleBegin</a><wbr>(<a href="../../types/transport/Begin.html" title="class in org.apache.qpid.protonj2.types.transport">Begin</a>&nbsp;begin,
 <a href="../../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;payload,
 int&nbsp;channel,
 <a href="ProtonEngine.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonEngine</a>&nbsp;context)</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="#handleClose(org.apache.qpid.protonj2.types.transport.Close,org.apache.qpid.protonj2.buffer.ProtonBuffer,int,org.apache.qpid.protonj2.engine.impl.ProtonEngine)" class="member-name-link">handleClose</a><wbr>(<a href="../../types/transport/Close.html" title="class in org.apache.qpid.protonj2.types.transport">Close</a>&nbsp;close,
 <a href="../../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;payload,
 int&nbsp;channel,
 <a href="ProtonEngine.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonEngine</a>&nbsp;context)</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>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#handleDetach(org.apache.qpid.protonj2.types.transport.Detach,org.apache.qpid.protonj2.buffer.ProtonBuffer,int,org.apache.qpid.protonj2.engine.impl.ProtonEngine)" class="member-name-link">handleDetach</a><wbr>(<a href="../../types/transport/Detach.html" title="class in org.apache.qpid.protonj2.types.transport">Detach</a>&nbsp;detach,
 <a href="../../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;payload,
 int&nbsp;channel,
 <a href="ProtonEngine.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonEngine</a>&nbsp;context)</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="#handleDisposition(org.apache.qpid.protonj2.types.transport.Disposition,org.apache.qpid.protonj2.buffer.ProtonBuffer,int,org.apache.qpid.protonj2.engine.impl.ProtonEngine)" class="member-name-link">handleDisposition</a><wbr>(<a href="../../types/transport/Disposition.html" title="class in org.apache.qpid.protonj2.types.transport">Disposition</a>&nbsp;disposition,
 <a href="../../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;payload,
 int&nbsp;channel,
 <a href="ProtonEngine.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonEngine</a>&nbsp;context)</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>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#handleEnd(org.apache.qpid.protonj2.types.transport.End,org.apache.qpid.protonj2.buffer.ProtonBuffer,int,org.apache.qpid.protonj2.engine.impl.ProtonEngine)" class="member-name-link">handleEnd</a><wbr>(<a href="../../types/transport/End.html" title="class in org.apache.qpid.protonj2.types.transport">End</a>&nbsp;end,
 <a href="../../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;payload,
 int&nbsp;channel,
 <a href="ProtonEngine.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonEngine</a>&nbsp;context)</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="#handleFlow(org.apache.qpid.protonj2.types.transport.Flow,org.apache.qpid.protonj2.buffer.ProtonBuffer,int,org.apache.qpid.protonj2.engine.impl.ProtonEngine)" class="member-name-link">handleFlow</a><wbr>(<a href="../../types/transport/Flow.html" title="class in org.apache.qpid.protonj2.types.transport">Flow</a>&nbsp;flow,
 <a href="../../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;payload,
 int&nbsp;channel,
 <a href="ProtonEngine.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonEngine</a>&nbsp;context)</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>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#handleOpen(org.apache.qpid.protonj2.types.transport.Open,org.apache.qpid.protonj2.buffer.ProtonBuffer,int,org.apache.qpid.protonj2.engine.impl.ProtonEngine)" class="member-name-link">handleOpen</a><wbr>(<a href="../../types/transport/Open.html" title="class in org.apache.qpid.protonj2.types.transport">Open</a>&nbsp;open,
 <a href="../../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;payload,
 int&nbsp;channel,
 <a href="ProtonEngine.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonEngine</a>&nbsp;context)</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="#handleSASLHeader(org.apache.qpid.protonj2.types.transport.AMQPHeader,org.apache.qpid.protonj2.engine.impl.ProtonEngine)" class="member-name-link">handleSASLHeader</a><wbr>(<a href="../../types/transport/AMQPHeader.html" title="class in org.apache.qpid.protonj2.types.transport">AMQPHeader</a>&nbsp;header,
 <a href="ProtonEngine.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonEngine</a>&nbsp;context)</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>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#handleTransfer(org.apache.qpid.protonj2.types.transport.Transfer,org.apache.qpid.protonj2.buffer.ProtonBuffer,int,org.apache.qpid.protonj2.engine.impl.ProtonEngine)" class="member-name-link">handleTransfer</a><wbr>(<a href="../../types/transport/Transfer.html" title="class in org.apache.qpid.protonj2.types.transport">Transfer</a>&nbsp;transfer,
 <a href="../../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;payload,
 int&nbsp;channel,
 <a href="ProtonEngine.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonEngine</a>&nbsp;context)</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>boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#isLocallyClosed()" class="member-name-link">isLocallyClosed</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns true if this <a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a> is currently locally closed meaning that a call to the
 <a href="../Endpoint.html#close()"><code>Endpoint.close()</code></a> method has occurred.</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="#isLocallyOpen()" class="member-name-link">isLocallyOpen</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns true if this <a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a> is currently locally open meaning that the <a href="../Endpoint.html#open()"><code>Endpoint.open()</code></a>
 has been called but the <a href="../Endpoint.html#close()"><code>Endpoint.close()</code></a> has not.</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="#isRemotelyClosed()" class="member-name-link">isRemotelyClosed</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns true if this <a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a> is currently remotely closed meaning that the AMQP performative
 that completes the close phase of this <a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a>'s lifetime has arrived.</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="#isRemotelyOpen()" class="member-name-link">isRemotelyOpen</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns true if this <a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a> is currently remotely open meaning that the AMQP performative
 that completes the open phase of this <a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a>'s lifetime has arrived but the performative
 that closes it has not.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#negotiate()" class="member-name-link">negotiate</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">If not already negotiated this method initiates the AMQP protocol negotiation phase of
 the connection process sending the <a href="../../types/transport/AMQPHeader.html" title="class in org.apache.qpid.protonj2.types.transport"><code>AMQPHeader</code></a> to the remote peer.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#negotiate(org.apache.qpid.protonj2.engine.EventHandler)" class="member-name-link">negotiate</a><wbr>(<a href="../EventHandler.html" title="interface in org.apache.qpid.protonj2.engine">EventHandler</a>&lt;<a href="../../types/transport/AMQPHeader.html" title="class in org.apache.qpid.protonj2.types.transport">AMQPHeader</a>&gt;&nbsp;remoteAMQPHeaderHandler)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">If not already negotiated this method initiates the AMQP protocol negotiation phase of
 the connection process sending the <a href="../../types/transport/AMQPHeader.html" title="class in org.apache.qpid.protonj2.types.transport"><code>AMQPHeader</code></a> to the remote peer.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ProtonConnection.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonConnection</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#open()" class="member-name-link">open</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Open the end point locally, sending the Open performative immediately if possible or holding
 it until SASL negotiations or the AMQP header exchange and other required performative exchanges
 has completed.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ProtonConnection.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonConnection</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#receiverOpenHandler(org.apache.qpid.protonj2.engine.EventHandler)" class="member-name-link">receiverOpenHandler</a><wbr>(<a href="../EventHandler.html" title="interface in org.apache.qpid.protonj2.engine">EventHandler</a>&lt;<a href="../Receiver.html" title="interface in org.apache.qpid.protonj2.engine">Receiver</a>&gt;&nbsp;remoteReceiverOpenEventHandler)</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="../EventHandler.html" title="interface in org.apache.qpid.protonj2.engine"><code>EventHandler</code></a> for when an AMQP Attach frame is received from the remote peer for a receiving link.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ProtonConnection.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonConnection</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#senderOpenHandler(org.apache.qpid.protonj2.engine.EventHandler)" class="member-name-link">senderOpenHandler</a><wbr>(<a href="../EventHandler.html" title="interface in org.apache.qpid.protonj2.engine">EventHandler</a>&lt;<a href="../Sender.html" title="interface in org.apache.qpid.protonj2.engine">Sender</a>&gt;&nbsp;remoteSenderOpenEventHandler)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets a <a href="../EventHandler.html" title="interface in org.apache.qpid.protonj2.engine"><code>EventHandler</code></a> for when an AMQP Attach frame is received from the remote peer for a sending link.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ProtonSession.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonSession</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#session()" class="member-name-link">session</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Creates a new Session linked to this Connection</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ProtonConnection.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonConnection</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#sessionOpenHandler(org.apache.qpid.protonj2.engine.EventHandler)" class="member-name-link">sessionOpenHandler</a><wbr>(<a href="../EventHandler.html" title="interface in org.apache.qpid.protonj2.engine">EventHandler</a>&lt;<a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</a>&gt;&nbsp;remoteSessionOpenEventHandler)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets a <a href="../EventHandler.html" title="interface in org.apache.qpid.protonj2.engine"><code>EventHandler</code></a> for when an AMQP Begin frame is received from the remote peer.</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/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</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="#sessions()" class="member-name-link">sessions</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns an unmodifiable <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Set.html" title="class or interface in java.util" class="external-link"><code>Set</code></a> of Sessions that are tracked by the Connection.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ProtonConnection.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonConnection</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setChannelMax(int)" class="member-name-link">setChannelMax</a><wbr>(int&nbsp;channelMax)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Set the channel max value for this Connection.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ProtonConnection.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonConnection</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setContainerId(java.lang.String)" class="member-name-link">setContainerId</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;containerId)</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 Container Id to be used when opening this Connection.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ProtonConnection.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonConnection</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setDesiredCapabilities(org.apache.qpid.protonj2.types.Symbol...)" class="member-name-link">setDesiredCapabilities</a><wbr>(<a href="../../types/Symbol.html" title="class in org.apache.qpid.protonj2.types">Symbol</a>...&nbsp;capabilities)</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 capabilities that are desired from the remote when this <a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a> is
 opened.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ProtonConnection.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonConnection</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setHostname(java.lang.String)" class="member-name-link">setHostname</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;hostname)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Set the name of the host (either fully qualified or relative) to which this
 connection is connecting to.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ProtonConnection.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonConnection</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setIdleTimeout(long)" class="member-name-link">setIdleTimeout</a><wbr>(long&nbsp;idleTimeout)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Set the idle timeout value for this Connection.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setMaxFrameSize(long)" class="member-name-link">setMaxFrameSize</a><wbr>(long&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">Sets the maximum frame size allowed for this connection, which is the largest single frame
 that the remote can send to this <a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine"><code>Connection</code></a> before it will close the connection with
 an error condition indicating the violation.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ProtonConnection.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonConnection</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setOfferedCapabilities(org.apache.qpid.protonj2.types.Symbol...)" class="member-name-link">setOfferedCapabilities</a><wbr>(<a href="../../types/Symbol.html" title="class in org.apache.qpid.protonj2.types">Symbol</a>...&nbsp;capabilities)</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 capabilities to be offered on to the remote when this <a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a> is
 opened.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ProtonConnection.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonConnection</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setProperties(java.util.Map)" class="member-name-link">setProperties</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="../../types/Symbol.html" title="class in org.apache.qpid.protonj2.types">Symbol</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 the properties to be sent to the remote when this <a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a> is Opened.</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="#tick(long)" class="member-name-link">tick</a><wbr>(long&nbsp;current)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Performs a tick operation on the connection which checks that Connection Idle timeout processing
 is run.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#tickAuto(java.util.concurrent.ScheduledExecutorService)" class="member-name-link">tickAuto</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/ScheduledExecutorService.html" title="class or interface in java.util.concurrent" class="external-link">ScheduledExecutorService</a>&nbsp;executor)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Convenience method which is the same as calling <a href="../Engine.html#tickAuto(java.util.concurrent.ScheduledExecutorService)"><code>Engine.tickAuto(ScheduledExecutorService)</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="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#tickAuto(org.apache.qpid.protonj2.engine.Scheduler)" class="member-name-link">tickAuto</a><wbr>(<a href="../Scheduler.html" title="interface in org.apache.qpid.protonj2.engine">Scheduler</a>&nbsp;scheduler)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Convenience method which is the same as calling <a href="../Engine.html#tickAuto(org.apache.qpid.protonj2.engine.Scheduler)"><code>Engine.tickAuto(Scheduler)</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="ProtonConnection.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonConnection</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#transactionManagerOpenHandler(org.apache.qpid.protonj2.engine.EventHandler)" class="member-name-link">transactionManagerOpenHandler</a><wbr>(<a href="../EventHandler.html" title="interface in org.apache.qpid.protonj2.engine">EventHandler</a>&lt;<a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a>&gt;&nbsp;remoteTxnManagerOpenEventHandler)</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="../EventHandler.html" title="interface in org.apache.qpid.protonj2.engine"><code>EventHandler</code></a> for when an AMQP Attach frame is received from the remote peer for a transaction
 coordination link.</div>
</div>
</div>
</div>
</div>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-org.apache.qpid.protonj2.engine.impl.ProtonEndpoint">Methods inherited from class&nbsp;org.apache.qpid.protonj2.engine.impl.<a href="ProtonEndpoint.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonEndpoint</a></h3>
<code><a href="ProtonEndpoint.html#closeHandler(org.apache.qpid.protonj2.engine.EventHandler)">closeHandler</a>, <a href="ProtonEndpoint.html#engineShutdownHandler(org.apache.qpid.protonj2.engine.EventHandler)">engineShutdownHandler</a>, <a href="ProtonEndpoint.html#getAttachments()">getAttachments</a>, <a href="ProtonEndpoint.html#getCondition()">getCondition</a>, <a href="ProtonEndpoint.html#getEngine()">getEngine</a>, <a href="ProtonEndpoint.html#getLinkedResource()">getLinkedResource</a>, <a href="ProtonEndpoint.html#getLinkedResource(java.lang.Class)">getLinkedResource</a>, <a href="ProtonEndpoint.html#getRemoteCondition()">getRemoteCondition</a>, <a href="ProtonEndpoint.html#localCloseHandler(org.apache.qpid.protonj2.engine.EventHandler)">localCloseHandler</a>, <a href="ProtonEndpoint.html#localOpenHandler(org.apache.qpid.protonj2.engine.EventHandler)">localOpenHandler</a>, <a href="ProtonEndpoint.html#openHandler(org.apache.qpid.protonj2.engine.EventHandler)">openHandler</a>, <a href="ProtonEndpoint.html#setCondition(org.apache.qpid.protonj2.types.transport.ErrorCondition)">setCondition</a>, <a href="ProtonEndpoint.html#setLinkedResource(java.lang.Object)">setLinkedResource</a></code></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#clone()" title="class or interface in java.lang" class="external-link">clone</a>, <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>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-org.apache.qpid.protonj2.engine.Endpoint">Methods inherited from interface&nbsp;org.apache.qpid.protonj2.engine.<a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine">Endpoint</a></h3>
<code><a href="../Endpoint.html#closeHandler(org.apache.qpid.protonj2.engine.EventHandler)">closeHandler</a>, <a href="../Endpoint.html#engineShutdownHandler(org.apache.qpid.protonj2.engine.EventHandler)">engineShutdownHandler</a>, <a href="../Endpoint.html#getAttachments()">getAttachments</a>, <a href="../Endpoint.html#getCondition()">getCondition</a>, <a href="../Endpoint.html#getEngine()">getEngine</a>, <a href="../Endpoint.html#getLinkedResource()">getLinkedResource</a>, <a href="../Endpoint.html#getLinkedResource(java.lang.Class)">getLinkedResource</a>, <a href="../Endpoint.html#getRemoteCondition()">getRemoteCondition</a>, <a href="../Endpoint.html#localCloseHandler(org.apache.qpid.protonj2.engine.EventHandler)">localCloseHandler</a>, <a href="../Endpoint.html#localOpenHandler(org.apache.qpid.protonj2.engine.EventHandler)">localOpenHandler</a>, <a href="../Endpoint.html#openHandler(org.apache.qpid.protonj2.engine.EventHandler)">openHandler</a>, <a href="../Endpoint.html#setCondition(org.apache.qpid.protonj2.types.transport.ErrorCondition)">setCondition</a>, <a href="../Endpoint.html#setLinkedResource(java.lang.Object)">setLinkedResource</a></code></div>
</section>
</li>
</ul>
</section>
<section class="details">
<ul class="details-list">
<!-- ============ METHOD DETAIL ========== -->
<li>
<section class="method-details" id="method-detail">
<h2>Method Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="getParent()">
<h3>getParent</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></span>&nbsp;<span class="element-name">getParent</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Endpoint.html#getParent()">Endpoint</a></code></span></div>
<div class="block">Gets the parent of this <a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a> which can be itself for <a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine"><code>Connection</code></a> instance.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Connection.html#getParent()">getParent</a></code>&nbsp;in interface&nbsp;<code><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code></dd>
<dt>Specified by:</dt>
<dd><code><a href="../Endpoint.html#getParent()">getParent</a></code>&nbsp;in interface&nbsp;<code><a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine">Endpoint</a>&lt;<a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a>&gt;</code></dd>
<dt>Returns:</dt>
<dd>this <a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine"><code>Connection</code></a> as it is the root of the <a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a> hierarchy.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getState()">
<h3>getState</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../ConnectionState.html" title="enum in org.apache.qpid.protonj2.engine">ConnectionState</a></span>&nbsp;<span class="element-name">getState</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Connection.html#getState()">getState</a></code>&nbsp;in interface&nbsp;<code><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code></dd>
<dt>Returns:</dt>
<dd>the local connection state only</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="open()">
<h3>open</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ProtonConnection.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonConnection</a></span>&nbsp;<span class="element-name">open</span>()
                      throws <span class="exceptions"><a href="../exceptions/EngineStateException.html" title="class in org.apache.qpid.protonj2.engine.exceptions">EngineStateException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Endpoint.html#open()">Endpoint</a></code></span></div>
<div class="block">Open the end point locally, sending the Open performative immediately if possible or holding
 it until SASL negotiations or the AMQP header exchange and other required performative exchanges
 has completed.

 The end point will signal any registered handler of the remote opening the Connection
 once the remote performative that signals open completion arrives.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Endpoint.html#open()">open</a></code>&nbsp;in interface&nbsp;<code><a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine">Endpoint</a>&lt;<a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a>&gt;</code></dd>
<dt>Returns:</dt>
<dd>this <a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a> instance.</dd>
<dt>Throws:</dt>
<dd><code><a href="../exceptions/EngineStateException.html" title="class in org.apache.qpid.protonj2.engine.exceptions">EngineStateException</a></code> - if an error occurs opening the Connection or the Engine is shutdown.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="close()">
<h3>close</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ProtonConnection.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonConnection</a></span>&nbsp;<span class="element-name">close</span>()
                       throws <span class="exceptions"><a href="../exceptions/EngineFailedException.html" title="class in org.apache.qpid.protonj2.engine.exceptions">EngineFailedException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Endpoint.html#close()">Endpoint</a></code></span></div>
<div class="block">Close the end point locally and send the closing performative immediately if possible or
 holds it until the Connection / Engine state allows it.  If the engine encounters an error writing
 the performative or the engine is in a failed state from a previous error then this method will
 throw an exception.  If the engine has been shutdown then this method will close out the local
 end of the <a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a> and clean up any local resources before returning normally.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Endpoint.html#close()">close</a></code>&nbsp;in interface&nbsp;<code><a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine">Endpoint</a>&lt;<a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a>&gt;</code></dd>
<dt>Returns:</dt>
<dd>this <a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a> instance.</dd>
<dt>Throws:</dt>
<dd><code><a href="../exceptions/EngineFailedException.html" title="class in org.apache.qpid.protonj2.engine.exceptions">EngineFailedException</a></code> - if an error occurs closing the end point or the Engine is in a failed state.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="negotiate()">
<h3>negotiate</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></span>&nbsp;<span class="element-name">negotiate</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Connection.html#negotiate()">Connection</a></code></span></div>
<div class="block">If not already negotiated this method initiates the AMQP protocol negotiation phase of
 the connection process sending the <a href="../../types/transport/AMQPHeader.html" title="class in org.apache.qpid.protonj2.types.transport"><code>AMQPHeader</code></a> to the remote peer.  For a client
 application this could mean requesting the server to indicate if it supports the version
 of the protocol this client speaks.  In rare cases a server could use this to preemptively
 send its AMQP header.

 Once a header is sent the remote should respond with the AMQP Header that indicates what
 protocol level it supports and if there is a mismatch the the engine will be failed with
 a error indicating the protocol support was not successfully negotiated.

 If the engine has a configured SASL layer then by starting the AMQP Header exchange this
 will implicitly first attempt the SASL authentication step of the connection process.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Connection.html#negotiate()">negotiate</a></code>&nbsp;in interface&nbsp;<code><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code></dd>
<dt>Returns:</dt>
<dd>this <a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine"><code>Connection</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="negotiate(org.apache.qpid.protonj2.engine.EventHandler)">
<h3>negotiate</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></span>&nbsp;<span class="element-name">negotiate</span><wbr><span class="parameters">(<a href="../EventHandler.html" title="interface in org.apache.qpid.protonj2.engine">EventHandler</a>&lt;<a href="../../types/transport/AMQPHeader.html" title="class in org.apache.qpid.protonj2.types.transport">AMQPHeader</a>&gt;&nbsp;remoteAMQPHeaderHandler)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Connection.html#negotiate(org.apache.qpid.protonj2.engine.EventHandler)">Connection</a></code></span></div>
<div class="block">If not already negotiated this method initiates the AMQP protocol negotiation phase of
 the connection process sending the <a href="../../types/transport/AMQPHeader.html" title="class in org.apache.qpid.protonj2.types.transport"><code>AMQPHeader</code></a> to the remote peer.  For a client
 application this could mean requesting the server to indicate if it supports the version
 of the protocol this client speaks.  In rare cases a server could use this to preemptively
 send its AMQP header.

 Once a header is sent the remote should respond with the AMQP Header that indicates what
 protocol level it supports and if there is a mismatch the the engine will be failed with
 a error indicating the protocol support was not successfully negotiated.

 If the engine has a configured SASL layer then by starting the AMQP Header exchange this
 will implicitly first attempt the SASL authentication step of the connection process.

 The provided remote AMQP Header handler will be called once the remote sends its AMQP Header to
 the either preemptively or as a response to offered AMQP Header from this peer, even if that has
 already happened prior to this call.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Connection.html#negotiate(org.apache.qpid.protonj2.engine.EventHandler)">negotiate</a></code>&nbsp;in interface&nbsp;<code><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code></dd>
<dt>Parameters:</dt>
<dd><code>remoteAMQPHeaderHandler</code> - Handler to be called when an AMQP Header response has arrived.</dd>
<dt>Returns:</dt>
<dd>this <a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine"><code>Connection</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="tick(long)">
<h3>tick</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">tick</span><wbr><span class="parameters">(long&nbsp;current)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Connection.html#tick(long)">Connection</a></code></span></div>
<div class="block">Performs a tick operation on the connection which checks that Connection Idle timeout processing
 is run.  This method is a convenience method that delegates the work to the <a href="../Engine.html#tick(long)"><code>Engine.tick(long)</code></a>
 method.

 It is an error to call this method if <a href="../Connection.html#tickAuto(java.util.concurrent.ScheduledExecutorService)"><code>Connection.tickAuto(ScheduledExecutorService)</code></a> was called.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Connection.html#tick(long)">tick</a></code>&nbsp;in interface&nbsp;<code><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code></dd>
<dt>Parameters:</dt>
<dd><code>current</code> - Current time value usually taken from <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/System.html#nanoTime()" title="class or interface in java.lang" class="external-link"><code>System.nanoTime()</code></a></dd>
<dt>Returns:</dt>
<dd>the absolute deadline in milliseconds to next call tick by/at, or 0 if there is none.</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../Engine.html#tick(long)"><code>Engine.tick(long)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="tickAuto(java.util.concurrent.ScheduledExecutorService)">
<h3>tickAuto</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></span>&nbsp;<span class="element-name">tickAuto</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/ScheduledExecutorService.html" title="class or interface in java.util.concurrent" class="external-link">ScheduledExecutorService</a>&nbsp;executor)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Connection.html#tickAuto(java.util.concurrent.ScheduledExecutorService)">Connection</a></code></span></div>
<div class="block">Convenience method which is the same as calling <a href="../Engine.html#tickAuto(java.util.concurrent.ScheduledExecutorService)"><code>Engine.tickAuto(ScheduledExecutorService)</code></a>.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Connection.html#tickAuto(java.util.concurrent.ScheduledExecutorService)">tickAuto</a></code>&nbsp;in interface&nbsp;<code><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code></dd>
<dt>Parameters:</dt>
<dd><code>executor</code> - The single threaded execution context where all engine work takes place.</dd>
<dt>Returns:</dt>
<dd>this <a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine"><code>Connection</code></a> instance.</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list-long">
<li><a href="../Engine.html#tickAuto(java.util.concurrent.ScheduledExecutorService)"><code>Engine.tickAuto(ScheduledExecutorService)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="tickAuto(org.apache.qpid.protonj2.engine.Scheduler)">
<h3>tickAuto</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></span>&nbsp;<span class="element-name">tickAuto</span><wbr><span class="parameters">(<a href="../Scheduler.html" title="interface in org.apache.qpid.protonj2.engine">Scheduler</a>&nbsp;scheduler)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Connection.html#tickAuto(org.apache.qpid.protonj2.engine.Scheduler)">Connection</a></code></span></div>
<div class="block">Convenience method which is the same as calling <a href="../Engine.html#tickAuto(org.apache.qpid.protonj2.engine.Scheduler)"><code>Engine.tickAuto(Scheduler)</code></a>.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Connection.html#tickAuto(org.apache.qpid.protonj2.engine.Scheduler)">tickAuto</a></code>&nbsp;in interface&nbsp;<code><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code></dd>
<dt>Parameters:</dt>
<dd><code>scheduler</code> - The single threaded execution context where all engine work takes place.</dd>
<dt>Returns:</dt>
<dd>this <a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine"><code>Connection</code></a> instance.</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../Engine.html#tickAuto(org.apache.qpid.protonj2.engine.Scheduler)"><code>Engine.tickAuto(Scheduler)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="isLocallyClosed()">
<h3>isLocallyClosed</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isLocallyClosed</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Endpoint.html#isLocallyClosed()">Endpoint</a></code></span></div>
<div class="block">Returns true if this <a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a> is currently locally closed meaning that a call to the
 <a href="../Endpoint.html#close()"><code>Endpoint.close()</code></a> method has occurred.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Endpoint.html#isLocallyClosed()">isLocallyClosed</a></code>&nbsp;in interface&nbsp;<code><a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine">Endpoint</a>&lt;<a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a>&gt;</code></dd>
<dt>Returns:</dt>
<dd><code>true</code> if the <a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a> is locally closed.</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../Endpoint.html#isLocallyOpen()"><code>Endpoint.isLocallyOpen()</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="isRemotelyClosed()">
<h3>isRemotelyClosed</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isRemotelyClosed</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Endpoint.html#isRemotelyClosed()">Endpoint</a></code></span></div>
<div class="block">Returns true if this <a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a> is currently remotely closed meaning that the AMQP performative
 that completes the close phase of this <a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a>'s lifetime has arrived.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Endpoint.html#isRemotelyClosed()">isRemotelyClosed</a></code>&nbsp;in interface&nbsp;<code><a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine">Endpoint</a>&lt;<a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a>&gt;</code></dd>
<dt>Returns:</dt>
<dd><code>true</code> if the <a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a> is remotely closed.</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../Endpoint.html#isRemotelyOpen()"><code>Endpoint.isRemotelyOpen()</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setContainerId(java.lang.String)">
<h3>setContainerId</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ProtonConnection.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonConnection</a></span>&nbsp;<span class="element-name">setContainerId</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;containerId)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Connection.html#setContainerId(java.lang.String)">Connection</a></code></span></div>
<div class="block">Sets the Container Id to be used when opening this Connection.  The container Id can only
 be modified prior to a call to <a href="../Endpoint.html#open()"><code>Endpoint.open()</code></a>, once the connection has been
 opened locally an error will be thrown if this method is called.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Connection.html#setContainerId(java.lang.String)">setContainerId</a></code>&nbsp;in interface&nbsp;<code><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code></dd>
<dt>Parameters:</dt>
<dd><code>containerId</code> - The Container Id used for this end of the Connection.</dd>
<dt>Returns:</dt>
<dd>this connection.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getContainerId()">
<h3>getContainerId</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">getContainerId</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Connection.html#getContainerId()">getContainerId</a></code>&nbsp;in interface&nbsp;<code><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code></dd>
<dt>Returns:</dt>
<dd>the Container ID assigned to this Connection</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setHostname(java.lang.String)">
<h3>setHostname</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ProtonConnection.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonConnection</a></span>&nbsp;<span class="element-name">setHostname</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;hostname)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Connection.html#setHostname(java.lang.String)">Connection</a></code></span></div>
<div class="block">Set the name of the host (either fully qualified or relative) to which this
 connection is connecting to.  This information may be used by the remote peer
 to determine the correct back-end service to connect the client to. This value
 will be sent in the Open performative.

 <b>Note that it is illegal to set the host name to a numeric IP
 address or include a port number.</b>

 The host name value can only be modified prior to a call to <a href="../Endpoint.html#open()"><code>Endpoint.open()</code></a>,
 once the connection has been opened locally an error will be thrown if this method
 is called.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Connection.html#setHostname(java.lang.String)">setHostname</a></code>&nbsp;in interface&nbsp;<code><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code></dd>
<dt>Parameters:</dt>
<dd><code>hostname</code> - the RFC1035 compliant host name.</dd>
<dt>Returns:</dt>
<dd>this connection.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getHostname()">
<h3>getHostname</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">getHostname</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Connection.html#getHostname()">getHostname</a></code>&nbsp;in interface&nbsp;<code><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code></dd>
<dt>Returns:</dt>
<dd>returns the host name assigned to this Connection.</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list-long">
<li><a href="../Connection.html#setHostname(java.lang.String)"><code>Connection.setHostname(java.lang.String)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setMaxFrameSize(long)">
<h3>setMaxFrameSize</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></span>&nbsp;<span class="element-name">setMaxFrameSize</span><wbr><span class="parameters">(long&nbsp;maxFrameSize)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Connection.html#setMaxFrameSize(long)">Connection</a></code></span></div>
<div class="block">Sets the maximum frame size allowed for this connection, which is the largest single frame
 that the remote can send to this <a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine"><code>Connection</code></a> before it will close the connection with
 an error condition indicating the violation.

 The legal range for this value is defined as (512 - 2^32-1) bytes.

 The max frame size value can only be modified prior to a call to <a href="../Endpoint.html#open()"><code>Endpoint.open()</code></a>,
 once the connection has been opened locally an error will be thrown if this method
 is called.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Connection.html#setMaxFrameSize(long)">setMaxFrameSize</a></code>&nbsp;in interface&nbsp;<code><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code></dd>
<dt>Parameters:</dt>
<dd><code>maxFrameSize</code> - The maximum number of bytes allowed for a single</dd>
<dt>Returns:</dt>
<dd>this connection.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getMaxFrameSize()">
<h3>getMaxFrameSize</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">getMaxFrameSize</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Connection.html#getMaxFrameSize()">getMaxFrameSize</a></code>&nbsp;in interface&nbsp;<code><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code></dd>
<dt>Returns:</dt>
<dd>the currently configured max frame size this connection will accept.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setChannelMax(int)">
<h3>setChannelMax</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ProtonConnection.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonConnection</a></span>&nbsp;<span class="element-name">setChannelMax</span><wbr><span class="parameters">(int&nbsp;channelMax)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Connection.html#setChannelMax(int)">Connection</a></code></span></div>
<div class="block">Set the channel max value for this Connection.

 The channel max value can only be modified prior to a call to <a href="../Endpoint.html#open()"><code>Endpoint.open()</code></a>,
 once the connection has been opened locally an error will be thrown if this method
 is called.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Connection.html#setChannelMax(int)">setChannelMax</a></code>&nbsp;in interface&nbsp;<code><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code></dd>
<dt>Parameters:</dt>
<dd><code>channelMax</code> - The value to set for channel max when opening the connection.</dd>
<dt>Returns:</dt>
<dd>this connection.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getChannelMax()">
<h3>getChannelMax</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">getChannelMax</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Connection.html#getChannelMax()">getChannelMax</a></code>&nbsp;in interface&nbsp;<code><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code></dd>
<dt>Returns:</dt>
<dd>the currently configured channel max for this <a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine"><code>Connection</code></a></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setIdleTimeout(long)">
<h3>setIdleTimeout</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ProtonConnection.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonConnection</a></span>&nbsp;<span class="element-name">setIdleTimeout</span><wbr><span class="parameters">(long&nbsp;idleTimeout)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Connection.html#setIdleTimeout(long)">Connection</a></code></span></div>
<div class="block">Set the idle timeout value for this Connection.

 The idle timeout value can only be modified prior to a call to <a href="../Endpoint.html#open()"><code>Endpoint.open()</code></a>,
 once the connection has been opened locally an error will be thrown if this method
 is called.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Connection.html#setIdleTimeout(long)">setIdleTimeout</a></code>&nbsp;in interface&nbsp;<code><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code></dd>
<dt>Parameters:</dt>
<dd><code>idleTimeout</code> - The value to set for the idle timeout when opening the connection.</dd>
<dt>Returns:</dt>
<dd>this connection.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getIdleTimeout()">
<h3>getIdleTimeout</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">getIdleTimeout</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Connection.html#getIdleTimeout()">getIdleTimeout</a></code>&nbsp;in interface&nbsp;<code><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code></dd>
<dt>Returns:</dt>
<dd>the currently configured idle timeout for this <a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine"><code>Connection</code></a></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setOfferedCapabilities(org.apache.qpid.protonj2.types.Symbol...)">
<h3>setOfferedCapabilities</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ProtonConnection.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonConnection</a></span>&nbsp;<span class="element-name">setOfferedCapabilities</span><wbr><span class="parameters">(<a href="../../types/Symbol.html" title="class in org.apache.qpid.protonj2.types">Symbol</a>...&nbsp;capabilities)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Endpoint.html#setOfferedCapabilities(org.apache.qpid.protonj2.types.Symbol...)">Endpoint</a></code></span></div>
<div class="block">Sets the capabilities to be offered on to the remote when this <a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a> is
 opened.

 The offered capabilities value can only be modified prior to a call to <a href="../Endpoint.html#open()"><code>Endpoint.open()</code></a>,
 once the <a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a> has been opened locally an error will be thrown if this method
 is called.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Endpoint.html#setOfferedCapabilities(org.apache.qpid.protonj2.types.Symbol...)">setOfferedCapabilities</a></code>&nbsp;in interface&nbsp;<code><a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine">Endpoint</a>&lt;<a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a>&gt;</code></dd>
<dt>Parameters:</dt>
<dd><code>capabilities</code> - The capabilities to be offered to the remote when the <a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a> is opened.</dd>
<dt>Returns:</dt>
<dd>this <a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getOfferedCapabilities()">
<h3>getOfferedCapabilities</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../../types/Symbol.html" title="class in org.apache.qpid.protonj2.types">Symbol</a>[]</span>&nbsp;<span class="element-name">getOfferedCapabilities</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Endpoint.html#getOfferedCapabilities()">getOfferedCapabilities</a></code>&nbsp;in interface&nbsp;<code><a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine">Endpoint</a>&lt;<a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a>&gt;</code></dd>
<dt>Returns:</dt>
<dd>the configured capabilities that are offered to the remote when the <a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a> is opened.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setDesiredCapabilities(org.apache.qpid.protonj2.types.Symbol...)">
<h3>setDesiredCapabilities</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ProtonConnection.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonConnection</a></span>&nbsp;<span class="element-name">setDesiredCapabilities</span><wbr><span class="parameters">(<a href="../../types/Symbol.html" title="class in org.apache.qpid.protonj2.types">Symbol</a>...&nbsp;capabilities)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Endpoint.html#setDesiredCapabilities(org.apache.qpid.protonj2.types.Symbol...)">Endpoint</a></code></span></div>
<div class="block">Sets the capabilities that are desired from the remote when this <a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a> is
 opened.

 The desired capabilities value can only be modified prior to a call to <a href="../Endpoint.html#open()"><code>Endpoint.open()</code></a>,
 once the <a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a> has been opened locally an error will be thrown if this method
 is called.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Endpoint.html#setDesiredCapabilities(org.apache.qpid.protonj2.types.Symbol...)">setDesiredCapabilities</a></code>&nbsp;in interface&nbsp;<code><a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine">Endpoint</a>&lt;<a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a>&gt;</code></dd>
<dt>Parameters:</dt>
<dd><code>capabilities</code> - The capabilities desired from the remote when the <a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a> is opened.</dd>
<dt>Returns:</dt>
<dd>this <a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getDesiredCapabilities()">
<h3>getDesiredCapabilities</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../../types/Symbol.html" title="class in org.apache.qpid.protonj2.types">Symbol</a>[]</span>&nbsp;<span class="element-name">getDesiredCapabilities</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Endpoint.html#getDesiredCapabilities()">getDesiredCapabilities</a></code>&nbsp;in interface&nbsp;<code><a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine">Endpoint</a>&lt;<a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a>&gt;</code></dd>
<dt>Returns:</dt>
<dd>the configured desired capabilities that are sent to the remote when the Connection is opened.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setProperties(java.util.Map)">
<h3>setProperties</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ProtonConnection.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonConnection</a></span>&nbsp;<span class="element-name">setProperties</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="../../types/Symbol.html" title="class in org.apache.qpid.protonj2.types">Symbol</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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Endpoint.html#setProperties(java.util.Map)">Endpoint</a></code></span></div>
<div class="block">Sets the properties to be sent to the remote when this <a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a> is Opened.

 The <a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a> properties value can only be modified prior to a call to <a href="../Endpoint.html#open()"><code>Endpoint.open()</code></a>,
 once the <a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a> has been opened locally an error will be thrown if this method
 is called.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Endpoint.html#setProperties(java.util.Map)">setProperties</a></code>&nbsp;in interface&nbsp;<code><a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine">Endpoint</a>&lt;<a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a>&gt;</code></dd>
<dt>Parameters:</dt>
<dd><code>properties</code> - The properties that will be sent to the remote when this Connection is opened.</dd>
<dt>Returns:</dt>
<dd>this <a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getProperties()">
<h3>getProperties</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="../../types/Symbol.html" title="class in org.apache.qpid.protonj2.types">Symbol</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">getProperties</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Endpoint.html#getProperties()">getProperties</a></code>&nbsp;in interface&nbsp;<code><a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine">Endpoint</a>&lt;<a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a>&gt;</code></dd>
<dt>Returns:</dt>
<dd>the configured properties sent to the remote when this Connection is opened.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="isLocallyOpen()">
<h3>isLocallyOpen</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isLocallyOpen</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Endpoint.html#isLocallyOpen()">Endpoint</a></code></span></div>
<div class="block">Returns true if this <a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a> is currently locally open meaning that the <a href="../Endpoint.html#open()"><code>Endpoint.open()</code></a>
 has been called but the <a href="../Endpoint.html#close()"><code>Endpoint.close()</code></a> has not.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Endpoint.html#isLocallyOpen()">isLocallyOpen</a></code>&nbsp;in interface&nbsp;<code><a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine">Endpoint</a>&lt;<a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a>&gt;</code></dd>
<dt>Returns:</dt>
<dd><code>true</code> if the <a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a> is locally open.</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../Endpoint.html#isLocallyClosed()"><code>Endpoint.isLocallyClosed()</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="isRemotelyOpen()">
<h3>isRemotelyOpen</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isRemotelyOpen</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Endpoint.html#isRemotelyOpen()">Endpoint</a></code></span></div>
<div class="block">Returns true if this <a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a> is currently remotely open meaning that the AMQP performative
 that completes the open phase of this <a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a>'s lifetime has arrived but the performative
 that closes it has not.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Endpoint.html#isRemotelyOpen()">isRemotelyOpen</a></code>&nbsp;in interface&nbsp;<code><a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine">Endpoint</a>&lt;<a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a>&gt;</code></dd>
<dt>Returns:</dt>
<dd><code>true</code> if the <a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a> is remotely open.</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../Endpoint.html#isRemotelyClosed()"><code>Endpoint.isRemotelyClosed()</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getRemoteContainerId()">
<h3>getRemoteContainerId</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">getRemoteContainerId</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Connection.html#getRemoteContainerId()">getRemoteContainerId</a></code>&nbsp;in interface&nbsp;<code><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code></dd>
<dt>Returns:</dt>
<dd>the Container Id assigned to the remote end of the Connection.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getRemoteHostname()">
<h3>getRemoteHostname</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">getRemoteHostname</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Connection.html#getRemoteHostname()">getRemoteHostname</a></code>&nbsp;in interface&nbsp;<code><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code></dd>
<dt>Returns:</dt>
<dd>the host name assigned to the remote end of this Connection.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getRemoteMaxFrameSize()">
<h3>getRemoteMaxFrameSize</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">getRemoteMaxFrameSize</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Connection.html#getRemoteMaxFrameSize()">getRemoteMaxFrameSize</a></code>&nbsp;in interface&nbsp;<code><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code></dd>
<dt>Returns:</dt>
<dd>the remote set max frame size limit.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getRemoteIdleTimeout()">
<h3>getRemoteIdleTimeout</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">getRemoteIdleTimeout</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Connection.html#getRemoteIdleTimeout()">getRemoteIdleTimeout</a></code>&nbsp;in interface&nbsp;<code><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code></dd>
<dt>Returns:</dt>
<dd>the idle timeout value provided by the remote end of this Connection.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getRemoteOfferedCapabilities()">
<h3>getRemoteOfferedCapabilities</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../../types/Symbol.html" title="class in org.apache.qpid.protonj2.types">Symbol</a>[]</span>&nbsp;<span class="element-name">getRemoteOfferedCapabilities</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Endpoint.html#getRemoteOfferedCapabilities()">getRemoteOfferedCapabilities</a></code>&nbsp;in interface&nbsp;<code><a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine">Endpoint</a>&lt;<a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a>&gt;</code></dd>
<dt>Returns:</dt>
<dd>the capabilities offered by the remote when it opened its end of the <a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a>.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getRemoteDesiredCapabilities()">
<h3>getRemoteDesiredCapabilities</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../../types/Symbol.html" title="class in org.apache.qpid.protonj2.types">Symbol</a>[]</span>&nbsp;<span class="element-name">getRemoteDesiredCapabilities</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Endpoint.html#getRemoteDesiredCapabilities()">getRemoteDesiredCapabilities</a></code>&nbsp;in interface&nbsp;<code><a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine">Endpoint</a>&lt;<a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a>&gt;</code></dd>
<dt>Returns:</dt>
<dd>the capabilities desired by the remote when it opened its end of the <a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a>.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getRemoteProperties()">
<h3>getRemoteProperties</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="../../types/Symbol.html" title="class in org.apache.qpid.protonj2.types">Symbol</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">getRemoteProperties</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Endpoint.html#getRemoteProperties()">getRemoteProperties</a></code>&nbsp;in interface&nbsp;<code><a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine">Endpoint</a>&lt;<a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a>&gt;</code></dd>
<dt>Returns:</dt>
<dd>the properties sent by the remote when it opened its end of the <a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a>.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getRemoteState()">
<h3>getRemoteState</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../ConnectionState.html" title="enum in org.apache.qpid.protonj2.engine">ConnectionState</a></span>&nbsp;<span class="element-name">getRemoteState</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Connection.html#getRemoteState()">getRemoteState</a></code>&nbsp;in interface&nbsp;<code><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code></dd>
<dt>Returns:</dt>
<dd>the remote state (as last communicated)</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="session()">
<h3>session</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ProtonSession.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonSession</a></span>&nbsp;<span class="element-name">session</span>()
                      throws <span class="exceptions"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/IllegalStateException.html" title="class or interface in java.lang" class="external-link">IllegalStateException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Connection.html#session()">Connection</a></code></span></div>
<div class="block">Creates a new Session linked to this Connection</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Connection.html#session()">session</a></code>&nbsp;in interface&nbsp;<code><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code></dd>
<dt>Returns:</dt>
<dd>a newly created <a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine"><code>Session</code></a> linked to this <a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine"><code>Connection</code></a>.</dd>
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/IllegalStateException.html" title="class or interface in java.lang" class="external-link">IllegalStateException</a></code> - if the <a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine"><code>Connection</code></a> has already been closed.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="sessions()">
<h3>sessions</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/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</a>&gt;</span>&nbsp;<span class="element-name">sessions</span>()
                      throws <span class="exceptions"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/IllegalStateException.html" title="class or interface in java.lang" class="external-link">IllegalStateException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Connection.html#sessions()">Connection</a></code></span></div>
<div class="block">Returns an unmodifiable <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Set.html" title="class or interface in java.util" class="external-link"><code>Set</code></a> of Sessions that are tracked by the Connection.

 The <a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine"><code>Session</code></a> instances returned from this method will be locally or remotely open or
 both which gives the caller full view of the complete set of known <a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine"><code>Session</code></a> instances.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Connection.html#sessions()">sessions</a></code>&nbsp;in interface&nbsp;<code><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code></dd>
<dt>Returns:</dt>
<dd>an unmodifiable <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Set.html" title="class or interface in java.util" class="external-link"><code>Set</code></a> of Sessions tracked by this Connection.</dd>
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/IllegalStateException.html" title="class or interface in java.lang" class="external-link">IllegalStateException</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="handleAMQPHeader(org.apache.qpid.protonj2.types.transport.AMQPHeader,org.apache.qpid.protonj2.engine.impl.ProtonEngine)">
<h3>handleAMQPHeader</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">handleAMQPHeader</span><wbr><span class="parameters">(<a href="../../types/transport/AMQPHeader.html" title="class in org.apache.qpid.protonj2.types.transport">AMQPHeader</a>&nbsp;header,
 <a href="ProtonEngine.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonEngine</a>&nbsp;context)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../../types/transport/AMQPHeader.HeaderHandler.html#handleAMQPHeader(org.apache.qpid.protonj2.types.transport.AMQPHeader,E)">handleAMQPHeader</a></code>&nbsp;in interface&nbsp;<code><a href="../../types/transport/AMQPHeader.HeaderHandler.html" title="interface in org.apache.qpid.protonj2.types.transport">AMQPHeader.HeaderHandler</a>&lt;<a href="ProtonEngine.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonEngine</a>&gt;</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="handleSASLHeader(org.apache.qpid.protonj2.types.transport.AMQPHeader,org.apache.qpid.protonj2.engine.impl.ProtonEngine)">
<h3>handleSASLHeader</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">handleSASLHeader</span><wbr><span class="parameters">(<a href="../../types/transport/AMQPHeader.html" title="class in org.apache.qpid.protonj2.types.transport">AMQPHeader</a>&nbsp;header,
 <a href="ProtonEngine.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonEngine</a>&nbsp;context)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../../types/transport/AMQPHeader.HeaderHandler.html#handleSASLHeader(org.apache.qpid.protonj2.types.transport.AMQPHeader,E)">handleSASLHeader</a></code>&nbsp;in interface&nbsp;<code><a href="../../types/transport/AMQPHeader.HeaderHandler.html" title="interface in org.apache.qpid.protonj2.types.transport">AMQPHeader.HeaderHandler</a>&lt;<a href="ProtonEngine.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonEngine</a>&gt;</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="handleOpen(org.apache.qpid.protonj2.types.transport.Open,org.apache.qpid.protonj2.buffer.ProtonBuffer,int,org.apache.qpid.protonj2.engine.impl.ProtonEngine)">
<h3>handleOpen</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">handleOpen</span><wbr><span class="parameters">(<a href="../../types/transport/Open.html" title="class in org.apache.qpid.protonj2.types.transport">Open</a>&nbsp;open,
 <a href="../../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;payload,
 int&nbsp;channel,
 <a href="ProtonEngine.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonEngine</a>&nbsp;context)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../../types/transport/Performative.PerformativeHandler.html#handleOpen(org.apache.qpid.protonj2.types.transport.Open,org.apache.qpid.protonj2.buffer.ProtonBuffer,int,E)">handleOpen</a></code>&nbsp;in interface&nbsp;<code><a href="../../types/transport/Performative.PerformativeHandler.html" title="interface in org.apache.qpid.protonj2.types.transport">Performative.PerformativeHandler</a>&lt;<a href="ProtonEngine.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonEngine</a>&gt;</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="handleClose(org.apache.qpid.protonj2.types.transport.Close,org.apache.qpid.protonj2.buffer.ProtonBuffer,int,org.apache.qpid.protonj2.engine.impl.ProtonEngine)">
<h3>handleClose</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">handleClose</span><wbr><span class="parameters">(<a href="../../types/transport/Close.html" title="class in org.apache.qpid.protonj2.types.transport">Close</a>&nbsp;close,
 <a href="../../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;payload,
 int&nbsp;channel,
 <a href="ProtonEngine.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonEngine</a>&nbsp;context)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../../types/transport/Performative.PerformativeHandler.html#handleClose(org.apache.qpid.protonj2.types.transport.Close,org.apache.qpid.protonj2.buffer.ProtonBuffer,int,E)">handleClose</a></code>&nbsp;in interface&nbsp;<code><a href="../../types/transport/Performative.PerformativeHandler.html" title="interface in org.apache.qpid.protonj2.types.transport">Performative.PerformativeHandler</a>&lt;<a href="ProtonEngine.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonEngine</a>&gt;</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="handleBegin(org.apache.qpid.protonj2.types.transport.Begin,org.apache.qpid.protonj2.buffer.ProtonBuffer,int,org.apache.qpid.protonj2.engine.impl.ProtonEngine)">
<h3>handleBegin</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">handleBegin</span><wbr><span class="parameters">(<a href="../../types/transport/Begin.html" title="class in org.apache.qpid.protonj2.types.transport">Begin</a>&nbsp;begin,
 <a href="../../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;payload,
 int&nbsp;channel,
 <a href="ProtonEngine.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonEngine</a>&nbsp;context)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../../types/transport/Performative.PerformativeHandler.html#handleBegin(org.apache.qpid.protonj2.types.transport.Begin,org.apache.qpid.protonj2.buffer.ProtonBuffer,int,E)">handleBegin</a></code>&nbsp;in interface&nbsp;<code><a href="../../types/transport/Performative.PerformativeHandler.html" title="interface in org.apache.qpid.protonj2.types.transport">Performative.PerformativeHandler</a>&lt;<a href="ProtonEngine.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonEngine</a>&gt;</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="handleEnd(org.apache.qpid.protonj2.types.transport.End,org.apache.qpid.protonj2.buffer.ProtonBuffer,int,org.apache.qpid.protonj2.engine.impl.ProtonEngine)">
<h3>handleEnd</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">handleEnd</span><wbr><span class="parameters">(<a href="../../types/transport/End.html" title="class in org.apache.qpid.protonj2.types.transport">End</a>&nbsp;end,
 <a href="../../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;payload,
 int&nbsp;channel,
 <a href="ProtonEngine.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonEngine</a>&nbsp;context)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../../types/transport/Performative.PerformativeHandler.html#handleEnd(org.apache.qpid.protonj2.types.transport.End,org.apache.qpid.protonj2.buffer.ProtonBuffer,int,E)">handleEnd</a></code>&nbsp;in interface&nbsp;<code><a href="../../types/transport/Performative.PerformativeHandler.html" title="interface in org.apache.qpid.protonj2.types.transport">Performative.PerformativeHandler</a>&lt;<a href="ProtonEngine.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonEngine</a>&gt;</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="handleAttach(org.apache.qpid.protonj2.types.transport.Attach,org.apache.qpid.protonj2.buffer.ProtonBuffer,int,org.apache.qpid.protonj2.engine.impl.ProtonEngine)">
<h3>handleAttach</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">handleAttach</span><wbr><span class="parameters">(<a href="../../types/transport/Attach.html" title="class in org.apache.qpid.protonj2.types.transport">Attach</a>&nbsp;attach,
 <a href="../../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;payload,
 int&nbsp;channel,
 <a href="ProtonEngine.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonEngine</a>&nbsp;context)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../../types/transport/Performative.PerformativeHandler.html#handleAttach(org.apache.qpid.protonj2.types.transport.Attach,org.apache.qpid.protonj2.buffer.ProtonBuffer,int,E)">handleAttach</a></code>&nbsp;in interface&nbsp;<code><a href="../../types/transport/Performative.PerformativeHandler.html" title="interface in org.apache.qpid.protonj2.types.transport">Performative.PerformativeHandler</a>&lt;<a href="ProtonEngine.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonEngine</a>&gt;</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="handleDetach(org.apache.qpid.protonj2.types.transport.Detach,org.apache.qpid.protonj2.buffer.ProtonBuffer,int,org.apache.qpid.protonj2.engine.impl.ProtonEngine)">
<h3>handleDetach</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">handleDetach</span><wbr><span class="parameters">(<a href="../../types/transport/Detach.html" title="class in org.apache.qpid.protonj2.types.transport">Detach</a>&nbsp;detach,
 <a href="../../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;payload,
 int&nbsp;channel,
 <a href="ProtonEngine.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonEngine</a>&nbsp;context)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../../types/transport/Performative.PerformativeHandler.html#handleDetach(org.apache.qpid.protonj2.types.transport.Detach,org.apache.qpid.protonj2.buffer.ProtonBuffer,int,E)">handleDetach</a></code>&nbsp;in interface&nbsp;<code><a href="../../types/transport/Performative.PerformativeHandler.html" title="interface in org.apache.qpid.protonj2.types.transport">Performative.PerformativeHandler</a>&lt;<a href="ProtonEngine.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonEngine</a>&gt;</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="handleFlow(org.apache.qpid.protonj2.types.transport.Flow,org.apache.qpid.protonj2.buffer.ProtonBuffer,int,org.apache.qpid.protonj2.engine.impl.ProtonEngine)">
<h3>handleFlow</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">handleFlow</span><wbr><span class="parameters">(<a href="../../types/transport/Flow.html" title="class in org.apache.qpid.protonj2.types.transport">Flow</a>&nbsp;flow,
 <a href="../../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;payload,
 int&nbsp;channel,
 <a href="ProtonEngine.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonEngine</a>&nbsp;context)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../../types/transport/Performative.PerformativeHandler.html#handleFlow(org.apache.qpid.protonj2.types.transport.Flow,org.apache.qpid.protonj2.buffer.ProtonBuffer,int,E)">handleFlow</a></code>&nbsp;in interface&nbsp;<code><a href="../../types/transport/Performative.PerformativeHandler.html" title="interface in org.apache.qpid.protonj2.types.transport">Performative.PerformativeHandler</a>&lt;<a href="ProtonEngine.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonEngine</a>&gt;</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="handleTransfer(org.apache.qpid.protonj2.types.transport.Transfer,org.apache.qpid.protonj2.buffer.ProtonBuffer,int,org.apache.qpid.protonj2.engine.impl.ProtonEngine)">
<h3>handleTransfer</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">handleTransfer</span><wbr><span class="parameters">(<a href="../../types/transport/Transfer.html" title="class in org.apache.qpid.protonj2.types.transport">Transfer</a>&nbsp;transfer,
 <a href="../../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;payload,
 int&nbsp;channel,
 <a href="ProtonEngine.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonEngine</a>&nbsp;context)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../../types/transport/Performative.PerformativeHandler.html#handleTransfer(org.apache.qpid.protonj2.types.transport.Transfer,org.apache.qpid.protonj2.buffer.ProtonBuffer,int,E)">handleTransfer</a></code>&nbsp;in interface&nbsp;<code><a href="../../types/transport/Performative.PerformativeHandler.html" title="interface in org.apache.qpid.protonj2.types.transport">Performative.PerformativeHandler</a>&lt;<a href="ProtonEngine.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonEngine</a>&gt;</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="handleDisposition(org.apache.qpid.protonj2.types.transport.Disposition,org.apache.qpid.protonj2.buffer.ProtonBuffer,int,org.apache.qpid.protonj2.engine.impl.ProtonEngine)">
<h3>handleDisposition</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">handleDisposition</span><wbr><span class="parameters">(<a href="../../types/transport/Disposition.html" title="class in org.apache.qpid.protonj2.types.transport">Disposition</a>&nbsp;disposition,
 <a href="../../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;payload,
 int&nbsp;channel,
 <a href="ProtonEngine.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonEngine</a>&nbsp;context)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../../types/transport/Performative.PerformativeHandler.html#handleDisposition(org.apache.qpid.protonj2.types.transport.Disposition,org.apache.qpid.protonj2.buffer.ProtonBuffer,int,E)">handleDisposition</a></code>&nbsp;in interface&nbsp;<code><a href="../../types/transport/Performative.PerformativeHandler.html" title="interface in org.apache.qpid.protonj2.types.transport">Performative.PerformativeHandler</a>&lt;<a href="ProtonEngine.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonEngine</a>&gt;</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="sessionOpenHandler(org.apache.qpid.protonj2.engine.EventHandler)">
<h3>sessionOpenHandler</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ProtonConnection.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonConnection</a></span>&nbsp;<span class="element-name">sessionOpenHandler</span><wbr><span class="parameters">(<a href="../EventHandler.html" title="interface in org.apache.qpid.protonj2.engine">EventHandler</a>&lt;<a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</a>&gt;&nbsp;remoteSessionOpenEventHandler)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Connection.html#sessionOpenHandler(org.apache.qpid.protonj2.engine.EventHandler)">Connection</a></code></span></div>
<div class="block">Sets a <a href="../EventHandler.html" title="interface in org.apache.qpid.protonj2.engine"><code>EventHandler</code></a> for when an AMQP Begin frame is received from the remote peer.

 Used to process remotely initiated Sessions. Locally initiated sessions have their own EventHandler
 invoked instead.  This method is Typically used by servers to listen for remote Session creation.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Connection.html#sessionOpenHandler(org.apache.qpid.protonj2.engine.EventHandler)">sessionOpenHandler</a></code>&nbsp;in interface&nbsp;<code><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code></dd>
<dt>Parameters:</dt>
<dd><code>remoteSessionOpenEventHandler</code> - the EventHandler that will be signaled when a session is remotely opened.</dd>
<dt>Returns:</dt>
<dd>this connection</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="senderOpenHandler(org.apache.qpid.protonj2.engine.EventHandler)">
<h3>senderOpenHandler</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ProtonConnection.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonConnection</a></span>&nbsp;<span class="element-name">senderOpenHandler</span><wbr><span class="parameters">(<a href="../EventHandler.html" title="interface in org.apache.qpid.protonj2.engine">EventHandler</a>&lt;<a href="../Sender.html" title="interface in org.apache.qpid.protonj2.engine">Sender</a>&gt;&nbsp;remoteSenderOpenEventHandler)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Connection.html#senderOpenHandler(org.apache.qpid.protonj2.engine.EventHandler)">Connection</a></code></span></div>
<div class="block">Sets a <a href="../EventHandler.html" title="interface in org.apache.qpid.protonj2.engine"><code>EventHandler</code></a> for when an AMQP Attach frame is received from the remote peer for a sending link.

 Used to process remotely initiated sending link.  Locally initiated links have their own EventHandler
 invoked instead.  This method is Typically used by servers to listen for remote Receiver creation.
 If an event handler for remote sender open is registered on the Session that the link is owned by then
 that handler will be invoked instead of this one.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Connection.html#senderOpenHandler(org.apache.qpid.protonj2.engine.EventHandler)">senderOpenHandler</a></code>&nbsp;in interface&nbsp;<code><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code></dd>
<dt>Parameters:</dt>
<dd><code>remoteSenderOpenEventHandler</code> - the EventHandler that will be signaled when a sender link is remotely opened.</dd>
<dt>Returns:</dt>
<dd>this connection</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="receiverOpenHandler(org.apache.qpid.protonj2.engine.EventHandler)">
<h3>receiverOpenHandler</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ProtonConnection.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonConnection</a></span>&nbsp;<span class="element-name">receiverOpenHandler</span><wbr><span class="parameters">(<a href="../EventHandler.html" title="interface in org.apache.qpid.protonj2.engine">EventHandler</a>&lt;<a href="../Receiver.html" title="interface in org.apache.qpid.protonj2.engine">Receiver</a>&gt;&nbsp;remoteReceiverOpenEventHandler)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Connection.html#receiverOpenHandler(org.apache.qpid.protonj2.engine.EventHandler)">Connection</a></code></span></div>
<div class="block">Sets a <a href="../EventHandler.html" title="interface in org.apache.qpid.protonj2.engine"><code>EventHandler</code></a> for when an AMQP Attach frame is received from the remote peer for a receiving link.

 Used to process remotely initiated receiving link.  Locally initiated links have their own EventHandler
 invoked instead.  This method is Typically used by servers to listen for remote Sender creation.
 If an event handler for remote receiver open is registered on the Session that the link is owned by then
 that handler will be invoked instead of this one.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Connection.html#receiverOpenHandler(org.apache.qpid.protonj2.engine.EventHandler)">receiverOpenHandler</a></code>&nbsp;in interface&nbsp;<code><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code></dd>
<dt>Parameters:</dt>
<dd><code>remoteReceiverOpenEventHandler</code> - the EventHandler that will be signaled when a receiver link is remotely opened.</dd>
<dt>Returns:</dt>
<dd>this connection</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="transactionManagerOpenHandler(org.apache.qpid.protonj2.engine.EventHandler)">
<h3>transactionManagerOpenHandler</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ProtonConnection.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonConnection</a></span>&nbsp;<span class="element-name">transactionManagerOpenHandler</span><wbr><span class="parameters">(<a href="../EventHandler.html" title="interface in org.apache.qpid.protonj2.engine">EventHandler</a>&lt;<a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a>&gt;&nbsp;remoteTxnManagerOpenEventHandler)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Connection.html#transactionManagerOpenHandler(org.apache.qpid.protonj2.engine.EventHandler)">Connection</a></code></span></div>
<div class="block">Sets a <a href="../EventHandler.html" title="interface in org.apache.qpid.protonj2.engine"><code>EventHandler</code></a> for when an AMQP Attach frame is received from the remote peer for a transaction
 coordination link.

 Used to process remotely initiated transaction manager link.  Locally initiated links have their own EventHandler
 invoked instead.  This method is Typically used by servers to listen for remote <a href="../TransactionController.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionController</code></a>
 creation.  If an event handler for remote <a href="../TransactionController.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionController</code></a> open is registered on the Session that the
 link is owned by then that handler will be invoked instead of this one.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Connection.html#transactionManagerOpenHandler(org.apache.qpid.protonj2.engine.EventHandler)">transactionManagerOpenHandler</a></code>&nbsp;in interface&nbsp;<code><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code></dd>
<dt>Parameters:</dt>
<dd><code>remoteTxnManagerOpenEventHandler</code> - the EventHandler that will be signaled when a <a href="../TransactionController.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionController</code></a> link is remotely opened.</dd>
<dt>Returns:</dt>
<dd>this connection</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; 2023 <a href="https://www.apache.org/">The Apache Software Foundation</a>. All rights reserved.</small></p>
</footer>
</div>
</div>
</body>
</html>
