<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>ProtonSession (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: ProtonSession">
<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/ProtonSession.html">Use</a></li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../../../help-doc.html#class">Help</a></li>
</ul>
</div>
<div class="sub-nav">
<div>
<ul class="sub-nav-list">
<li>Summary:&nbsp;</li>
<li>Nested&nbsp;|&nbsp;</li>
<li><a href="#field-summary">Field</a>&nbsp;|&nbsp;</li>
<li><a href="#constructor-summary">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method-summary">Method</a></li>
</ul>
<ul class="sub-nav-list">
<li>Detail:&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li><a href="#constructor-detail">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method-detail">Method</a></li>
</ul>
</div>
</div>
<!-- ========= END OF TOP NAVBAR ========= -->
<span class="skip-nav" id="skip-navbar-top"></span></nav>
</header>
<div class="flex-content">
<main role="main">
<!-- ======== START OF CLASS DATA ======== -->
<div class="header">
<div class="sub-title"><span class="package-label-in-type">Package</span>&nbsp;<a href="package-summary.html">org.apache.qpid.protonj2.engine.impl</a></div>
<h1 title="Class ProtonSession" class="title">Class ProtonSession</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="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</a>&gt;
<div class="inheritance">org.apache.qpid.protonj2.engine.impl.ProtonSession</div>
</div>
</div>
<section class="class-description" id="class-description">
<dl class="notes">
<dt>All Implemented Interfaces:</dt>
<dd><code><a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine">Endpoint</a>&lt;<a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</a>&gt;</code>, <code><a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</a></code></dd>
</dl>
<hr>
<div class="type-signature"><span class="modifiers">public class </span><span class="element-name type-name-label">ProtonSession</span>
<span class="extends-implements">extends <a href="ProtonEndpoint.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonEndpoint</a>&lt;<a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</a>&gt;
implements <a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</a></span></div>
<div class="block">Proton API for Session type.</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>
<!-- ======== CONSTRUCTOR SUMMARY ======== -->
<li>
<section class="constructor-summary" id="constructor-summary">
<h2>Constructor Summary</h2>
<div class="caption"><span>Constructors</span></div>
<div class="summary-table two-column-summary">
<div class="table-header col-first">Constructor</div>
<div class="table-header col-last">Description</div>
<div class="col-constructor-name even-row-color"><code><a href="#%3Cinit%3E(org.apache.qpid.protonj2.engine.impl.ProtonConnection,int)" class="member-name-link">ProtonSession</a><wbr>(<a href="ProtonConnection.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonConnection</a>&nbsp;connection,
 int&nbsp;localChannel)</code></div>
<div class="col-last even-row-color">
<div class="block">Creates a new <a href="ProtonSession.html" title="class in org.apache.qpid.protonj2.engine.impl"><code>ProtonSession</code></a> instance bound to the given <a href="ProtonConnection.html" title="class in org.apache.qpid.protonj2.engine.impl"><code>ProtonConnection</code></a>.</div>
</div>
</div>
</section>
</li>
<!-- ========== METHOD SUMMARY =========== -->
<li>
<section class="method-summary" id="method-summary">
<h2>Method Summary</h2>
<div id="method-summary-table">
<div class="table-tabs" role="tablist" aria-orientation="horizontal"><button id="method-summary-table-tab0" role="tab" aria-selected="true" aria-controls="method-summary-table.tabpanel" tabindex="0" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table', 3)" class="active-table-tab">All Methods</button><button id="method-summary-table-tab2" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab2', 3)" class="table-tab">Instance Methods</button><button id="method-summary-table-tab4" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab4', 3)" class="table-tab">Concrete Methods</button></div>
<div id="method-summary-table.tabpanel" role="tabpanel">
<div class="summary-table three-column-summary" aria-labelledby="method-summary-table-tab0">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Method</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ProtonSession.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonSession</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><a href="../TransactionController.html" title="interface in org.apache.qpid.protonj2.engine">TransactionController</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#coordinator(java.lang.String)" class="member-name-link">coordinator</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;name)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Create a new <a href="../TransactionController.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionController</code></a> using the provided name.</div>
</div>
<div class="col-first even-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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#deliveryReadHandler(org.apache.qpid.protonj2.engine.EventHandler)" class="member-name-link">deliveryReadHandler</a><wbr>(<a href="../EventHandler.html" title="interface in org.apache.qpid.protonj2.engine">EventHandler</a>&lt;<a href="../IncomingDelivery.html" title="interface in org.apache.qpid.protonj2.engine">IncomingDelivery</a>&gt;&nbsp;deliveryReadHandler)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Allows monitoring of incoming deliveries to receivers attached to this <a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine"><code>Session</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="#getConnection()" class="member-name-link">getConnection</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="../../types/Symbol.html" title="class in org.apache.qpid.protonj2.types">Symbol</a>[]</code></div>
<div class="col-second even-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 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="#getHandleMax()" class="member-name-link">getHandleMax</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getIncomingCapacity()" class="member-name-link">getIncomingCapacity</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>int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getLocalChannel()" class="member-name-link">getLocalChannel</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="../../types/Symbol.html" title="class in org.apache.qpid.protonj2.types">Symbol</a>[]</code></div>
<div class="col-second even-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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getOutgoingCapacity()" class="member-name-link">getOutgoingCapacity</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="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="#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>int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getRemainingIncomingCapacity()" class="member-name-link">getRemainingIncomingCapacity</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>int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getRemainingOutgoingCapacity()" class="member-name-link">getRemainingOutgoingCapacity</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getRemoteChannel()" class="member-name-link">getRemoteChannel</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="../../types/Symbol.html" title="class in org.apache.qpid.protonj2.types">Symbol</a>[]</code></div>
<div class="col-second even-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 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="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="#getRemoteProperties()" class="member-name-link">getRemoteProperties</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="../SessionState.html" title="enum in org.apache.qpid.protonj2.engine">SessionState</a></code></div>
<div class="col-second even-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 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="../SessionState.html" title="enum in org.apache.qpid.protonj2.engine">SessionState</a></code></div>
<div class="col-second odd-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 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="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="../Link.html" title="interface in org.apache.qpid.protonj2.engine">Link</a>&lt;?&gt;&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#links()" class="member-name-link">links</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 a <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 all <a href="../Sender.html" title="interface in org.apache.qpid.protonj2.engine"><code>Sender</code></a> and <a href="../Receiver.html" title="interface in org.apache.qpid.protonj2.engine"><code>Receiver</code></a> instances that are being tracked by
 this <a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine"><code>Session</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="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="#open()" class="member-name-link">open</a>()</code></div>
<div class="col-last odd-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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ProtonReceiver.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonReceiver</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#receiver(java.lang.String)" class="member-name-link">receiver</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;name)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Create a new <a href="../Receiver.html" title="interface in org.apache.qpid.protonj2.engine"><code>Receiver</code></a> link using the provided name</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="#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="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="ProtonReceiver.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonReceiver</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="#receivers()" class="member-name-link">receivers</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 a <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 <a href="../Receiver.html" title="interface in org.apache.qpid.protonj2.engine"><code>Receiver</code></a> instances that are being tracked by this <a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine"><code>Session</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="ProtonSender.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonSender</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#sender(java.lang.String)" class="member-name-link">sender</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;name)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Create a new <a href="../Sender.html" title="interface in org.apache.qpid.protonj2.engine"><code>Sender</code></a> link using the provided name.</div>
</div>
<div class="col-first even-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 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="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="ProtonSender.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonSender</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="#senders()" class="member-name-link">senders</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 a <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 <a href="../Sender.html" title="interface in org.apache.qpid.protonj2.engine"><code>Sender</code></a> instances that are being tracked by this <a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine"><code>Session</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="ProtonSession.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonSession</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="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setHandleMax(long)" class="member-name-link">setHandleMax</a><wbr>(long&nbsp;handleMax)</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 handle max value for this Session.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setIncomingCapacity(int)" class="member-name-link">setIncomingCapacity</a><wbr>(int&nbsp;incomingCapacity)</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 maximum number of bytes this session can be sent from the remote.</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="#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 odd-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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setOutgoingCapacity(int)" class="member-name-link">setOutgoingCapacity</a><wbr>(int&nbsp;outgoingCapacity)</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 maximum number of bytes this session can be write before blocking additional
 sends until the written bytes are known to have been flushed to the write.</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="#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><a href="ProtonSession.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonSession</a></code></div>
<div class="col-second even-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 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 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">
<!-- ========= CONSTRUCTOR DETAIL ======== -->
<li>
<section class="constructor-details" id="constructor-detail">
<h2>Constructor Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="&lt;init&gt;(org.apache.qpid.protonj2.engine.impl.ProtonConnection,int)">
<h3>ProtonSession</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="element-name">ProtonSession</span><wbr><span class="parameters">(<a href="ProtonConnection.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonConnection</a>&nbsp;connection,
 int&nbsp;localChannel)</span></div>
<div class="block">Creates a new <a href="ProtonSession.html" title="class in org.apache.qpid.protonj2.engine.impl"><code>ProtonSession</code></a> instance bound to the given <a href="ProtonConnection.html" title="class in org.apache.qpid.protonj2.engine.impl"><code>ProtonConnection</code></a>.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>connection</code> - The connection that is the parent of the session instance.</dd>
<dd><code>localChannel</code> - The local channel onto which this session is bound.</dd>
</dl>
</section>
</li>
</ul>
</section>
</li>
<!-- ============ METHOD DETAIL ========== -->
<li>
<section class="method-details" id="method-detail">
<h2>Method Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="getConnection()">
<h3>getConnection</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">getConnection</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Session.html#getConnection()">getConnection</a></code>&nbsp;in interface&nbsp;<code><a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</a></code></dd>
<dt>Returns:</dt>
<dd>the parent <a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine"><code>Connection</code></a> for this Session.</dd>
</dl>
</section>
</li>
<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="ProtonConnection.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonConnection</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="../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="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</a>&gt;</code></dd>
<dt>Specified by:</dt>
<dd><code><a href="../Session.html#getParent()">getParent</a></code>&nbsp;in interface&nbsp;<code><a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</a></code></dd>
<dt>Returns:</dt>
<dd>the parent <a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine"><code>Connection</code></a> of the <a href="../Link.html" title="interface in org.apache.qpid.protonj2.engine"><code>Link</code></a></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getLocalChannel()">
<h3>getLocalChannel</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">getLocalChannel</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the local channel onto which this <a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine"><code>Session</code></a> is bound.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getRemoteChannel()">
<h3>getRemoteChannel</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">getRemoteChannel</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the remote channel onto which this <a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine"><code>Session</code></a> is bound or -1 if not yet remotely opened.</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="../SessionState.html" title="enum in org.apache.qpid.protonj2.engine">SessionState</a></span>&nbsp;<span class="element-name">getState</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Session.html#getState()">getState</a></code>&nbsp;in interface&nbsp;<code><a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</a></code></dd>
<dt>Returns:</dt>
<dd>the local session state</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="../SessionState.html" title="enum in org.apache.qpid.protonj2.engine">SessionState</a></span>&nbsp;<span class="element-name">getRemoteState</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Session.html#getRemoteState()">getRemoteState</a></code>&nbsp;in interface&nbsp;<code><a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</a></code></dd>
<dt>Returns:</dt>
<dd>the remote session state (as last communicated)</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="ProtonSession.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonSession</a></span>&nbsp;<span class="element-name">open</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>,
<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="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</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>
<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="close()">
<h3>close</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">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="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</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="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="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</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="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="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</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="setIncomingCapacity(int)">
<h3>setIncomingCapacity</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</a></span>&nbsp;<span class="element-name">setIncomingCapacity</span><wbr><span class="parameters">(int&nbsp;incomingCapacity)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Session.html#setIncomingCapacity(int)">Session</a></code></span></div>
<div class="block">Sets the maximum number of bytes this session can be sent from the remote.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Session.html#setIncomingCapacity(int)">setIncomingCapacity</a></code>&nbsp;in interface&nbsp;<code><a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</a></code></dd>
<dt>Parameters:</dt>
<dd><code>incomingCapacity</code> - maximum number of incoming bytes this session will allow</dd>
<dt>Returns:</dt>
<dd>this <a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine"><code>Session</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getIncomingCapacity()">
<h3>getIncomingCapacity</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">getIncomingCapacity</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Session.html#getIncomingCapacity()">getIncomingCapacity</a></code>&nbsp;in interface&nbsp;<code><a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</a></code></dd>
<dt>Returns:</dt>
<dd>the current incoming capacity of this session.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getRemainingIncomingCapacity()">
<h3>getRemainingIncomingCapacity</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">getRemainingIncomingCapacity</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Session.html#getRemainingIncomingCapacity()">getRemainingIncomingCapacity</a></code>&nbsp;in interface&nbsp;<code><a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</a></code></dd>
<dt>Returns:</dt>
<dd>the remaining session capacity based on how many bytes are currently pending,</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setOutgoingCapacity(int)">
<h3>setOutgoingCapacity</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</a></span>&nbsp;<span class="element-name">setOutgoingCapacity</span><wbr><span class="parameters">(int&nbsp;outgoingCapacity)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Session.html#setOutgoingCapacity(int)">Session</a></code></span></div>
<div class="block">Sets the maximum number of bytes this session can be write before blocking additional
 sends until the written bytes are known to have been flushed to the write.  This limit
 is intended to deal with issues of memory allocation when the I/O layer allows for
 asynchronous writes and finer grained control over the pending write buffers is needed.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Session.html#setOutgoingCapacity(int)">setOutgoingCapacity</a></code>&nbsp;in interface&nbsp;<code><a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</a></code></dd>
<dt>Parameters:</dt>
<dd><code>outgoingCapacity</code> - maximum number of outgoing bytes this session will allow before stopping senders from sending.</dd>
<dt>Returns:</dt>
<dd>this <a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine"><code>Session</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getOutgoingCapacity()">
<h3>getOutgoingCapacity</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">getOutgoingCapacity</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Session.html#getOutgoingCapacity()">getOutgoingCapacity</a></code>&nbsp;in interface&nbsp;<code><a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</a></code></dd>
<dt>Returns:</dt>
<dd>the current outgoing capacity limit of this session.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getRemainingOutgoingCapacity()">
<h3>getRemainingOutgoingCapacity</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">getRemainingOutgoingCapacity</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Session.html#getRemainingOutgoingCapacity()">getRemainingOutgoingCapacity</a></code>&nbsp;in interface&nbsp;<code><a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</a></code></dd>
<dt>Returns:</dt>
<dd>the remaining session outgoing capacity based on how many bytes are currently pending,</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setHandleMax(long)">
<h3>setHandleMax</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</a></span>&nbsp;<span class="element-name">setHandleMax</span><wbr><span class="parameters">(long&nbsp;handleMax)</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="../Session.html#setHandleMax(long)">Session</a></code></span></div>
<div class="block">Set the handle max value for this Session.

 The handle max value can only be modified prior to a call to <a href="../Endpoint.html#open()"><code>Endpoint.open()</code></a>,
 once the session 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="../Session.html#setHandleMax(long)">setHandleMax</a></code>&nbsp;in interface&nbsp;<code><a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</a></code></dd>
<dt>Parameters:</dt>
<dd><code>handleMax</code> - The value to set for handle max when opening the session.</dd>
<dt>Returns:</dt>
<dd>this <a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine"><code>Session</code></a> instance.</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 Session has already been opened.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getHandleMax()">
<h3>getHandleMax</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">getHandleMax</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Session.html#getHandleMax()">getHandleMax</a></code>&nbsp;in interface&nbsp;<code><a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</a></code></dd>
<dt>Returns:</dt>
<dd>the currently configured handle max for this <a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine"><code>Session</code></a></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="ProtonSession.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonSession</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="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</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="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</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="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="ProtonSession.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonSession</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="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</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="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</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="ProtonSession.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonSession</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="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</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="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</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="links()">
<h3>links</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="../Link.html" title="interface in org.apache.qpid.protonj2.engine">Link</a>&lt;?&gt;&gt;</span>&nbsp;<span class="element-name">links</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Session.html#links()">Session</a></code></span></div>
<div class="block">Returns a <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 all <a href="../Sender.html" title="interface in org.apache.qpid.protonj2.engine"><code>Sender</code></a> and <a href="../Receiver.html" title="interface in org.apache.qpid.protonj2.engine"><code>Receiver</code></a> instances that are being tracked by
 this <a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine"><code>Session</code></a>.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Session.html#links()">links</a></code>&nbsp;in interface&nbsp;<code><a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</a></code></dd>
<dt>Returns:</dt>
<dd>a set of Sender and Receiver instances tracked by this session.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="senders()">
<h3>senders</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="ProtonSender.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonSender</a>&gt;</span>&nbsp;<span class="element-name">senders</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Session.html#senders()">Session</a></code></span></div>
<div class="block">Returns a <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 <a href="../Sender.html" title="interface in org.apache.qpid.protonj2.engine"><code>Sender</code></a> instances that are being tracked by this <a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine"><code>Session</code></a>.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Session.html#senders()">senders</a></code>&nbsp;in interface&nbsp;<code><a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</a></code></dd>
<dt>Returns:</dt>
<dd>a set of Sender instances tracked by this session.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="receivers()">
<h3>receivers</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="ProtonReceiver.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonReceiver</a>&gt;</span>&nbsp;<span class="element-name">receivers</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Session.html#receivers()">Session</a></code></span></div>
<div class="block">Returns a <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 <a href="../Receiver.html" title="interface in org.apache.qpid.protonj2.engine"><code>Receiver</code></a> instances that are being tracked by this <a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine"><code>Session</code></a>.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Session.html#receivers()">receivers</a></code>&nbsp;in interface&nbsp;<code><a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</a></code></dd>
<dt>Returns:</dt>
<dd>a set of Receiver instances tracked by this session.</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="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</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="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="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</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="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="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</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="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</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="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</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="sender(java.lang.String)">
<h3>sender</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ProtonSender.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonSender</a></span>&nbsp;<span class="element-name">sender</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;name)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Session.html#sender(java.lang.String)">Session</a></code></span></div>
<div class="block">Create a new <a href="../Sender.html" title="interface in org.apache.qpid.protonj2.engine"><code>Sender</code></a> link using the provided name.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Session.html#sender(java.lang.String)">sender</a></code>&nbsp;in interface&nbsp;<code><a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</a></code></dd>
<dt>Parameters:</dt>
<dd><code>name</code> - The name to assign to the created <a href="../Sender.html" title="interface in org.apache.qpid.protonj2.engine"><code>Sender</code></a></dd>
<dt>Returns:</dt>
<dd>a newly created <a href="../Sender.html" title="interface in org.apache.qpid.protonj2.engine"><code>Sender</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="receiver(java.lang.String)">
<h3>receiver</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ProtonReceiver.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonReceiver</a></span>&nbsp;<span class="element-name">receiver</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;name)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Session.html#receiver(java.lang.String)">Session</a></code></span></div>
<div class="block">Create a new <a href="../Receiver.html" title="interface in org.apache.qpid.protonj2.engine"><code>Receiver</code></a> link using the provided name</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Session.html#receiver(java.lang.String)">receiver</a></code>&nbsp;in interface&nbsp;<code><a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</a></code></dd>
<dt>Parameters:</dt>
<dd><code>name</code> - The name to assign to the created <a href="../Receiver.html" title="interface in org.apache.qpid.protonj2.engine"><code>Receiver</code></a></dd>
<dt>Returns:</dt>
<dd>a newly created <a href="../Receiver.html" title="interface in org.apache.qpid.protonj2.engine"><code>Receiver</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="coordinator(java.lang.String)">
<h3>coordinator</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../TransactionController.html" title="interface in org.apache.qpid.protonj2.engine">TransactionController</a></span>&nbsp;<span class="element-name">coordinator</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;name)</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="../Session.html#coordinator(java.lang.String)">Session</a></code></span></div>
<div class="block">Create a new <a href="../TransactionController.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionController</code></a> using the provided name.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Session.html#coordinator(java.lang.String)">coordinator</a></code>&nbsp;in interface&nbsp;<code><a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</a></code></dd>
<dt>Parameters:</dt>
<dd><code>name</code> - The name to assign to the created <a href="../TransactionController.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionController</code></a></dd>
<dt>Returns:</dt>
<dd>a newly created <a href="../TransactionController.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionController</code></a> instance.</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="../Session.html" title="interface in org.apache.qpid.protonj2.engine"><code>Session</code></a> has already been closed.</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="ProtonSession.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonSession</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="../Session.html#senderOpenHandler(org.apache.qpid.protonj2.engine.EventHandler)">Session</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 this Session for a link scoped to it then
 this handler will be invoked instead of the variant in the Connection API.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Session.html#senderOpenHandler(org.apache.qpid.protonj2.engine.EventHandler)">senderOpenHandler</a></code>&nbsp;in interface&nbsp;<code><a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</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 session for chaining</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="ProtonSession.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonSession</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="../Session.html#receiverOpenHandler(org.apache.qpid.protonj2.engine.EventHandler)">Session</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 sender open is registered on this Session for a link scoped to it then
 this handler will be invoked instead of the variant in the Connection API.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Session.html#receiverOpenHandler(org.apache.qpid.protonj2.engine.EventHandler)">receiverOpenHandler</a></code>&nbsp;in interface&nbsp;<code><a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</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 session for chaining</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="ProtonSession.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonSession</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="../Session.html#transactionManagerOpenHandler(org.apache.qpid.protonj2.engine.EventHandler)">Session</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 this Session for a
 <a href="../TransactionController.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionController</code></a> scoped to it then this handler will be invoked instead of the variant in the
 <a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine"><code>Connection</code></a> API.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Session.html#transactionManagerOpenHandler(org.apache.qpid.protonj2.engine.EventHandler)">transactionManagerOpenHandler</a></code>&nbsp;in interface&nbsp;<code><a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</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 <a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</a> for chaining</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="deliveryReadHandler(org.apache.qpid.protonj2.engine.EventHandler)">
<h3>deliveryReadHandler</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">deliveryReadHandler</span><wbr><span class="parameters">(<a href="../EventHandler.html" title="interface in org.apache.qpid.protonj2.engine">EventHandler</a>&lt;<a href="../IncomingDelivery.html" title="interface in org.apache.qpid.protonj2.engine">IncomingDelivery</a>&gt;&nbsp;deliveryReadHandler)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Session.html#deliveryReadHandler(org.apache.qpid.protonj2.engine.EventHandler)">Session</a></code></span></div>
<div class="block">Allows monitoring of incoming deliveries to receivers attached to this <a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine"><code>Session</code></a>. The
 <a href="../Receiver.html" title="interface in org.apache.qpid.protonj2.engine"><code>Receiver</code></a> that is the target of the incoming delivery will be notified first of the
 incoming delivery and any processing should be done using the <a href="../Receiver.html#deliveryReadHandler(org.apache.qpid.protonj2.engine.EventHandler)"><code>Receiver.deliveryReadHandler(EventHandler)</code></a>.
 This event point will be trigger only after the <a href="../Receiver.html" title="interface in org.apache.qpid.protonj2.engine"><code>Receiver</code></a> level handler and should be
 used to monitor deliveries passing through a session for logging or other state related actions
 performed by the service managing this session.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Session.html#deliveryReadHandler(org.apache.qpid.protonj2.engine.EventHandler)">deliveryReadHandler</a></code>&nbsp;in interface&nbsp;<code><a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</a></code></dd>
<dt>Parameters:</dt>
<dd><code>deliveryReadHandler</code> - The delivery that was read which contains</dd>
<dt>Returns:</dt>
<dd>this <a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</a> for chaining</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>
