<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>ProtonTransactionManager (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: ProtonTransactionManager">
<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/ProtonTransactionManager.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 ProtonTransactionManager" class="title">Class ProtonTransactionManager</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="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a>&gt;
<div class="inheritance">org.apache.qpid.protonj2.engine.impl.ProtonTransactionManager</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="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a>&gt;</code>, <code><a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a></code></dd>
</dl>
<hr>
<div class="type-signature"><span class="modifiers">public final class </span><span class="element-name type-name-label">ProtonTransactionManager</span>
<span class="extends-implements">extends <a href="ProtonEndpoint.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonEndpoint</a>&lt;<a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a>&gt;
implements <a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a></span></div>
<div class="block"><a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionManager</code></a> implementation that implements the abstraction
 around a receiver link that responds to requests to <a href="../../types/transactions/Declare.html" title="class in org.apache.qpid.protonj2.types.transactions"><code>Declare</code></a> and to
 <a href="../../types/transactions/Discharge.html" title="class in org.apache.qpid.protonj2.types.transactions"><code>Discharge</code></a> AMQP <a href="../Transaction.html" title="interface in org.apache.qpid.protonj2.engine"><code>Transaction</code></a> instance.</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.ProtonReceiver)" class="member-name-link">ProtonTransactionManager</a><wbr>(<a href="ProtonReceiver.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonReceiver</a>&nbsp;receiverLink)</code></div>
<div class="col-last even-row-color">
<div class="block">Creates a new <a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionManager</code></a> instance that wraps the given <a href="../Receiver.html" title="interface in org.apache.qpid.protonj2.engine"><code>Receiver</code></a> link.</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="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#addCredit(int)" class="member-name-link">addCredit</a><wbr>(int&nbsp;additional)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Adds the given amount of credit for the <a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionManager</code></a> which allows
 the <a href="../TransactionController.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionController</code></a> to send <a href="../../types/transactions/Declare.html" title="class in org.apache.qpid.protonj2.types.transactions"><code>Declare</code></a> and <a href="../../types/transactions/Discharge.html" title="class in org.apache.qpid.protonj2.types.transactions"><code>Discharge</code></a>
 requests to this manager.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a></code></div>
<div class="col-second odd-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 odd-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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#declared(org.apache.qpid.protonj2.engine.Transaction,org.apache.qpid.protonj2.types.Binary)" class="member-name-link">declared</a><wbr>(<a href="../Transaction.html" title="interface in org.apache.qpid.protonj2.engine">Transaction</a>&lt;<a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a>&gt;&nbsp;transaction,
 <a href="../../types/Binary.html" title="class in org.apache.qpid.protonj2.types">Binary</a>&nbsp;txnId)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Respond to a previous <a href="../../types/transactions/Declare.html" title="class in org.apache.qpid.protonj2.types.transactions"><code>Declare</code></a> request from the remote <a href="../TransactionController.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionController</code></a>
 indicating that the requested transaction has been successfully declared and that deliveries
 can now be enlisted in that transaction.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#declareFailed(org.apache.qpid.protonj2.engine.Transaction,org.apache.qpid.protonj2.types.transport.ErrorCondition)" class="member-name-link">declareFailed</a><wbr>(<a href="../Transaction.html" title="interface in org.apache.qpid.protonj2.engine">Transaction</a>&lt;<a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a>&gt;&nbsp;transaction,
 <a href="../../types/transport/ErrorCondition.html" title="class in org.apache.qpid.protonj2.types.transport">ErrorCondition</a>&nbsp;condition)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Respond to a previous <a href="../../types/transactions/Declare.html" title="class in org.apache.qpid.protonj2.types.transactions"><code>Declare</code></a> request from the remote <a href="../TransactionController.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionController</code></a>
 indicating that the requested transaction declaration has failed and is not active.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#declareHandler(org.apache.qpid.protonj2.engine.EventHandler)" class="member-name-link">declareHandler</a><wbr>(<a href="../EventHandler.html" title="interface in org.apache.qpid.protonj2.engine">EventHandler</a>&lt;<a href="../Transaction.html" title="interface in org.apache.qpid.protonj2.engine">Transaction</a>&lt;<a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a>&gt;&gt;&nbsp;declaredEventHandler)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Called when the <a href="../TransactionController.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionController</code></a> end of the link has requested a new transaction be
 declared using the information provided in the given <a href="../../types/transactions/Declare.html" title="class in org.apache.qpid.protonj2.types.transactions"><code>Declare</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="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#discharged(org.apache.qpid.protonj2.engine.Transaction)" class="member-name-link">discharged</a><wbr>(<a href="../Transaction.html" title="interface in org.apache.qpid.protonj2.engine">Transaction</a>&lt;<a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a>&gt;&nbsp;transaction)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Respond to a previous <a href="../../types/transactions/Discharge.html" title="class in org.apache.qpid.protonj2.types.transactions"><code>Discharge</code></a> request from the remote <a href="../TransactionController.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionController</code></a>
 indicating that the discharge completed on the transaction identified by given transaction Id
 has now been retired.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#dischargeFailed(org.apache.qpid.protonj2.engine.Transaction,org.apache.qpid.protonj2.types.transport.ErrorCondition)" class="member-name-link">dischargeFailed</a><wbr>(<a href="../Transaction.html" title="interface in org.apache.qpid.protonj2.engine">Transaction</a>&lt;<a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a>&gt;&nbsp;transaction,
 <a href="../../types/transport/ErrorCondition.html" title="class in org.apache.qpid.protonj2.types.transport">ErrorCondition</a>&nbsp;condition)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Respond to a previous <a href="../../types/transactions/Discharge.html" title="class in org.apache.qpid.protonj2.types.transactions"><code>Discharge</code></a> request from the remote <a href="../TransactionController.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionController</code></a>
 indicating that the discharge resulted in an error and the transaction must be considered rolled
 back.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#dischargeHandler(org.apache.qpid.protonj2.engine.EventHandler)" class="member-name-link">dischargeHandler</a><wbr>(<a href="../EventHandler.html" title="interface in org.apache.qpid.protonj2.engine">EventHandler</a>&lt;<a href="../Transaction.html" title="interface in org.apache.qpid.protonj2.engine">Transaction</a>&lt;<a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a>&gt;&gt;&nbsp;dischargeEventHandler)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Called when the <a href="../TransactionController.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionController</code></a> end of the link has requested a current transaction be
 discharged using the information provided in the given <a href="../../types/transactions/Discharge.html" title="class in org.apache.qpid.protonj2.types.transactions"><code>Discharge</code></a> instance.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../../types/transport/ErrorCondition.html" title="class in org.apache.qpid.protonj2.types.transport">ErrorCondition</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getCondition()" class="member-name-link">getCondition</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/transactions/Coordinator.html" title="class in org.apache.qpid.protonj2.types.transactions">Coordinator</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getCoordinator()" class="member-name-link">getCoordinator</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 the currently set Coordinator target for this <a href="../Link.html" title="interface in org.apache.qpid.protonj2.engine"><code>Link</code></a>.</div>
</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="#getCredit()" class="member-name-link">getCredit</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Get the credit that is currently available or assigned to this <a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionManager</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="../../types/Symbol.html" title="class in org.apache.qpid.protonj2.types">Symbol</a>[]</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getDesiredCapabilities()" class="member-name-link">getDesiredCapabilities</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../../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><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="#getParent()" class="member-name-link">getParent</a>()</code></div>
<div class="col-last odd-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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="../../types/Symbol.html" title="class in org.apache.qpid.protonj2.types">Symbol</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getProperties()" class="member-name-link">getProperties</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/transport/ErrorCondition.html" title="class in org.apache.qpid.protonj2.types.transport">ErrorCondition</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getRemoteCondition()" class="member-name-link">getRemoteCondition</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">If the remote has closed this <a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a> and provided an <a href="../../types/transport/ErrorCondition.html" title="class in org.apache.qpid.protonj2.types.transport"><code>ErrorCondition</code></a> as part
 of the closing AMQP performative then this method will return it.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../../types/transactions/Coordinator.html" title="class in org.apache.qpid.protonj2.types.transactions">Coordinator</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getRemoteCoordinator()" class="member-name-link">getRemoteCoordinator</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 the remote target <a href="../../types/messaging/Terminus.html" title="interface in org.apache.qpid.protonj2.types.messaging"><code>Terminus</code></a> for this transaction manager which must be of type
 <a href="../../types/transactions/Coordinator.html" title="class in org.apache.qpid.protonj2.types.transactions"><code>Coordinator</code></a> or null if remote did not set a terminus.</div>
</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="../../types/messaging/Source.html" title="class in org.apache.qpid.protonj2.types.messaging">Source</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getRemoteSource()" class="member-name-link">getRemoteSource</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/messaging/Source.html" title="class in org.apache.qpid.protonj2.types.messaging">Source</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getSource()" class="member-name-link">getSource</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="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#open()" class="member-name-link">open</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Open the end point locally, sending the Open performative immediately if possible or holding
 it until SASL negotiations or the AMQP header exchange and other required performative exchanges
 has completed.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#parentEndpointClosedHandler(org.apache.qpid.protonj2.engine.EventHandler)" class="member-name-link">parentEndpointClosedHandler</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;handler)</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 the parent <a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine"><code>Session</code></a> or <a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine"><code>Connection</code></a> of this <a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionManager</code></a>
 is locally closed.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setCondition(org.apache.qpid.protonj2.types.transport.ErrorCondition)" class="member-name-link">setCondition</a><wbr>(<a href="../../types/transport/ErrorCondition.html" title="class in org.apache.qpid.protonj2.types.transport">ErrorCondition</a>&nbsp;condition)</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 local <a href="../../types/transport/ErrorCondition.html" title="class in org.apache.qpid.protonj2.types.transport"><code>ErrorCondition</code></a> to be applied to a <a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a> close.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setCoordinator(org.apache.qpid.protonj2.types.transactions.Coordinator)" class="member-name-link">setCoordinator</a><wbr>(<a href="../../types/transactions/Coordinator.html" title="class in org.apache.qpid.protonj2.types.transactions">Coordinator</a>&nbsp;coordinator)</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 <a href="../../types/transactions/Coordinator.html" title="class in org.apache.qpid.protonj2.types.transactions"><code>Coordinator</code></a> target to assign to the local end of this <a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionManager</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="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</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;desiredCapabilities)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets the 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="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</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;offeredCapabilities)</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="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a></code></div>
<div class="col-second even-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 even-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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setSource(org.apache.qpid.protonj2.types.messaging.Source)" class="member-name-link">setSource</a><wbr>(<a href="../../types/messaging/Source.html" title="class in org.apache.qpid.protonj2.types.messaging">Source</a>&nbsp;source)</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 <a href="../../types/messaging/Source.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>Source</code></a> to assign to the local end of this <a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionManager</code></a>.</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#getEngine()">getEngine</a>, <a href="ProtonEndpoint.html#getLinkedResource()">getLinkedResource</a>, <a href="ProtonEndpoint.html#getLinkedResource(java.lang.Class)">getLinkedResource</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#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#getEngine()">getEngine</a>, <a href="../Endpoint.html#getLinkedResource()">getLinkedResource</a>, <a href="../Endpoint.html#getLinkedResource(java.lang.Class)">getLinkedResource</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#setLinkedResource(java.lang.Object)">setLinkedResource</a></code></div>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-org.apache.qpid.protonj2.engine.TransactionManager">Methods inherited from interface&nbsp;org.apache.qpid.protonj2.engine.<a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a></h3>
<code><a href="../TransactionManager.html#declared(org.apache.qpid.protonj2.engine.Transaction,byte%5B%5D)">declared</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.ProtonReceiver)">
<h3>ProtonTransactionManager</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="element-name">ProtonTransactionManager</span><wbr><span class="parameters">(<a href="ProtonReceiver.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonReceiver</a>&nbsp;receiverLink)</span></div>
<div class="block">Creates a new <a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionManager</code></a> instance that wraps the given <a href="../Receiver.html" title="interface in org.apache.qpid.protonj2.engine"><code>Receiver</code></a> link.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>receiverLink</code> - The <a href="../Receiver.html" title="interface in org.apache.qpid.protonj2.engine"><code>Receiver</code></a> link that this <a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionManager</code></a> wraps.</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="getParent()">
<h3>getParent</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">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="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a>&gt;</code></dd>
<dt>Returns:</dt>
<dd>the parent of this <a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a> or itself if this is a <a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine"><code>Connection</code></a>;</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="addCredit(int)">
<h3>addCredit</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a></span>&nbsp;<span class="element-name">addCredit</span><wbr><span class="parameters">(int&nbsp;additional)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../TransactionManager.html#addCredit(int)">TransactionManager</a></code></span></div>
<div class="block">Adds the given amount of credit for the <a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionManager</code></a> which allows
 the <a href="../TransactionController.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionController</code></a> to send <a href="../../types/transactions/Declare.html" title="class in org.apache.qpid.protonj2.types.transactions"><code>Declare</code></a> and <a href="../../types/transactions/Discharge.html" title="class in org.apache.qpid.protonj2.types.transactions"><code>Discharge</code></a>
 requests to this manager.  The <a href="../TransactionController.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionController</code></a> cannot send any requests
 to start or complete a transaction without having credit to do so which implies that
 the <a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionManager</code></a> owner must grant credit as part of its normal processing.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../TransactionManager.html#addCredit(int)">addCredit</a></code>&nbsp;in interface&nbsp;<code><a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a></code></dd>
<dt>Parameters:</dt>
<dd><code>additional</code> - the new amount of credits to add.</dd>
<dt>Returns:</dt>
<dd>this <a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionManager</code></a></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getCredit()">
<h3>getCredit</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">getCredit</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../TransactionManager.html#getCredit()">TransactionManager</a></code></span></div>
<div class="block">Get the credit that is currently available or assigned to this <a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionManager</code></a>.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../TransactionManager.html#getCredit()">getCredit</a></code>&nbsp;in interface&nbsp;<code><a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a></code></dd>
<dt>Returns:</dt>
<dd>the current unused credit.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="declared(org.apache.qpid.protonj2.engine.Transaction,org.apache.qpid.protonj2.types.Binary)">
<h3>declared</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a></span>&nbsp;<span class="element-name">declared</span><wbr><span class="parameters">(<a href="../Transaction.html" title="interface in org.apache.qpid.protonj2.engine">Transaction</a>&lt;<a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a>&gt;&nbsp;transaction,
 <a href="../../types/Binary.html" title="class in org.apache.qpid.protonj2.types">Binary</a>&nbsp;txnId)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../TransactionManager.html#declared(org.apache.qpid.protonj2.engine.Transaction,org.apache.qpid.protonj2.types.Binary)">TransactionManager</a></code></span></div>
<div class="block">Respond to a previous <a href="../../types/transactions/Declare.html" title="class in org.apache.qpid.protonj2.types.transactions"><code>Declare</code></a> request from the remote <a href="../TransactionController.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionController</code></a>
 indicating that the requested transaction has been successfully declared and that deliveries
 can now be enlisted in that transaction.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../TransactionManager.html#declared(org.apache.qpid.protonj2.engine.Transaction,org.apache.qpid.protonj2.types.Binary)">declared</a></code>&nbsp;in interface&nbsp;<code><a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a></code></dd>
<dt>Parameters:</dt>
<dd><code>transaction</code> - The transaction instance that is associated with the declared transaction.</dd>
<dd><code>txnId</code> - The binary transaction Id to assign the now declared transaction instance.</dd>
<dt>Returns:</dt>
<dd>this <a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionManager</code></a>.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="discharged(org.apache.qpid.protonj2.engine.Transaction)">
<h3>discharged</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a></span>&nbsp;<span class="element-name">discharged</span><wbr><span class="parameters">(<a href="../Transaction.html" title="interface in org.apache.qpid.protonj2.engine">Transaction</a>&lt;<a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a>&gt;&nbsp;transaction)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../TransactionManager.html#discharged(org.apache.qpid.protonj2.engine.Transaction)">TransactionManager</a></code></span></div>
<div class="block">Respond to a previous <a href="../../types/transactions/Discharge.html" title="class in org.apache.qpid.protonj2.types.transactions"><code>Discharge</code></a> request from the remote <a href="../TransactionController.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionController</code></a>
 indicating that the discharge completed on the transaction identified by given transaction Id
 has now been retired.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../TransactionManager.html#discharged(org.apache.qpid.protonj2.engine.Transaction)">discharged</a></code>&nbsp;in interface&nbsp;<code><a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a></code></dd>
<dt>Parameters:</dt>
<dd><code>transaction</code> - The <a href="../Transaction.html" title="interface in org.apache.qpid.protonj2.engine"><code>Transaction</code></a> instance that has been discharged and is now retired.</dd>
<dt>Returns:</dt>
<dd>this <a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionManager</code></a>.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="declareFailed(org.apache.qpid.protonj2.engine.Transaction,org.apache.qpid.protonj2.types.transport.ErrorCondition)">
<h3>declareFailed</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a></span>&nbsp;<span class="element-name">declareFailed</span><wbr><span class="parameters">(<a href="../Transaction.html" title="interface in org.apache.qpid.protonj2.engine">Transaction</a>&lt;<a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a>&gt;&nbsp;transaction,
 <a href="../../types/transport/ErrorCondition.html" title="class in org.apache.qpid.protonj2.types.transport">ErrorCondition</a>&nbsp;condition)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../TransactionManager.html#declareFailed(org.apache.qpid.protonj2.engine.Transaction,org.apache.qpid.protonj2.types.transport.ErrorCondition)">TransactionManager</a></code></span></div>
<div class="block">Respond to a previous <a href="../../types/transactions/Declare.html" title="class in org.apache.qpid.protonj2.types.transactions"><code>Declare</code></a> request from the remote <a href="../TransactionController.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionController</code></a>
 indicating that the requested transaction declaration has failed and is not active.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../TransactionManager.html#declareFailed(org.apache.qpid.protonj2.engine.Transaction,org.apache.qpid.protonj2.types.transport.ErrorCondition)">declareFailed</a></code>&nbsp;in interface&nbsp;<code><a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a></code></dd>
<dt>Parameters:</dt>
<dd><code>transaction</code> - The transaction instance that is associated with the declared transaction.</dd>
<dd><code>condition</code> - The <a href="../../types/transport/ErrorCondition.html" title="class in org.apache.qpid.protonj2.types.transport"><code>ErrorCondition</code></a> that described the reason for the transaction failure.</dd>
<dt>Returns:</dt>
<dd>this <a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionManager</code></a>.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="dischargeFailed(org.apache.qpid.protonj2.engine.Transaction,org.apache.qpid.protonj2.types.transport.ErrorCondition)">
<h3>dischargeFailed</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a></span>&nbsp;<span class="element-name">dischargeFailed</span><wbr><span class="parameters">(<a href="../Transaction.html" title="interface in org.apache.qpid.protonj2.engine">Transaction</a>&lt;<a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a>&gt;&nbsp;transaction,
 <a href="../../types/transport/ErrorCondition.html" title="class in org.apache.qpid.protonj2.types.transport">ErrorCondition</a>&nbsp;condition)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../TransactionManager.html#dischargeFailed(org.apache.qpid.protonj2.engine.Transaction,org.apache.qpid.protonj2.types.transport.ErrorCondition)">TransactionManager</a></code></span></div>
<div class="block">Respond to a previous <a href="../../types/transactions/Discharge.html" title="class in org.apache.qpid.protonj2.types.transactions"><code>Discharge</code></a> request from the remote <a href="../TransactionController.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionController</code></a>
 indicating that the discharge resulted in an error and the transaction must be considered rolled
 back.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../TransactionManager.html#dischargeFailed(org.apache.qpid.protonj2.engine.Transaction,org.apache.qpid.protonj2.types.transport.ErrorCondition)">dischargeFailed</a></code>&nbsp;in interface&nbsp;<code><a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a></code></dd>
<dt>Parameters:</dt>
<dd><code>transaction</code> - The <a href="../Transaction.html" title="interface in org.apache.qpid.protonj2.engine"><code>Transaction</code></a> instance that has been discharged and is now retired.</dd>
<dd><code>condition</code> - The <a href="../../types/transport/ErrorCondition.html" title="class in org.apache.qpid.protonj2.types.transport"><code>ErrorCondition</code></a> that described the reason for the transaction failure.</dd>
<dt>Returns:</dt>
<dd>this <a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionManager</code></a>.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="declareHandler(org.apache.qpid.protonj2.engine.EventHandler)">
<h3>declareHandler</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a></span>&nbsp;<span class="element-name">declareHandler</span><wbr><span class="parameters">(<a href="../EventHandler.html" title="interface in org.apache.qpid.protonj2.engine">EventHandler</a>&lt;<a href="../Transaction.html" title="interface in org.apache.qpid.protonj2.engine">Transaction</a>&lt;<a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a>&gt;&gt;&nbsp;declaredEventHandler)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../TransactionManager.html#declareHandler(org.apache.qpid.protonj2.engine.EventHandler)">TransactionManager</a></code></span></div>
<div class="block">Called when the <a href="../TransactionController.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionController</code></a> end of the link has requested a new transaction be
 declared using the information provided in the given <a href="../../types/transactions/Declare.html" title="class in org.apache.qpid.protonj2.types.transactions"><code>Declare</code></a> instance.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../TransactionManager.html#declareHandler(org.apache.qpid.protonj2.engine.EventHandler)">declareHandler</a></code>&nbsp;in interface&nbsp;<code><a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a></code></dd>
<dt>Parameters:</dt>
<dd><code>declaredEventHandler</code> - handler that will act on the transaction declaration request.</dd>
<dt>Returns:</dt>
<dd>this <a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionManager</code></a>.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="dischargeHandler(org.apache.qpid.protonj2.engine.EventHandler)">
<h3>dischargeHandler</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a></span>&nbsp;<span class="element-name">dischargeHandler</span><wbr><span class="parameters">(<a href="../EventHandler.html" title="interface in org.apache.qpid.protonj2.engine">EventHandler</a>&lt;<a href="../Transaction.html" title="interface in org.apache.qpid.protonj2.engine">Transaction</a>&lt;<a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a>&gt;&gt;&nbsp;dischargeEventHandler)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../TransactionManager.html#dischargeHandler(org.apache.qpid.protonj2.engine.EventHandler)">TransactionManager</a></code></span></div>
<div class="block">Called when the <a href="../TransactionController.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionController</code></a> end of the link has requested a current transaction be
 discharged using the information provided in the given <a href="../../types/transactions/Discharge.html" title="class in org.apache.qpid.protonj2.types.transactions"><code>Discharge</code></a> instance.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../TransactionManager.html#dischargeHandler(org.apache.qpid.protonj2.engine.EventHandler)">dischargeHandler</a></code>&nbsp;in interface&nbsp;<code><a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a></code></dd>
<dt>Parameters:</dt>
<dd><code>dischargeEventHandler</code> - handler that will act on the transaction declaration request.</dd>
<dt>Returns:</dt>
<dd>this <a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionManager</code></a>.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="parentEndpointClosedHandler(org.apache.qpid.protonj2.engine.EventHandler)">
<h3>parentEndpointClosedHandler</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a></span>&nbsp;<span class="element-name">parentEndpointClosedHandler</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;handler)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../TransactionManager.html#parentEndpointClosedHandler(org.apache.qpid.protonj2.engine.EventHandler)">TransactionManager</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 the parent <a href="../Session.html" title="interface in org.apache.qpid.protonj2.engine"><code>Session</code></a> or <a href="../Connection.html" title="interface in org.apache.qpid.protonj2.engine"><code>Connection</code></a> of this <a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionManager</code></a>
 is locally closed.

 Typically used by clients for logging or other state update event processing.  Clients should not perform any
 blocking calls within this context.  It is an error for the handler to throw an exception and the outcome of
 doing so is undefined.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../TransactionManager.html#parentEndpointClosedHandler(org.apache.qpid.protonj2.engine.EventHandler)">parentEndpointClosedHandler</a></code>&nbsp;in interface&nbsp;<code><a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a></code></dd>
<dt>Parameters:</dt>
<dd><code>handler</code> - The <a href="../EventHandler.html" title="interface in org.apache.qpid.protonj2.engine"><code>EventHandler</code></a> to notify when this transaction manger's parent endpoint is locally closed.</dd>
<dt>Returns:</dt>
<dd>the link for chaining.</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="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</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="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</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="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</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="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</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="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</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="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</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="setSource(org.apache.qpid.protonj2.types.messaging.Source)">
<h3>setSource</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a></span>&nbsp;<span class="element-name">setSource</span><wbr><span class="parameters">(<a href="../../types/messaging/Source.html" title="class in org.apache.qpid.protonj2.types.messaging">Source</a>&nbsp;source)</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="../TransactionManager.html#setSource(org.apache.qpid.protonj2.types.messaging.Source)">TransactionManager</a></code></span></div>
<div class="block">Sets the <a href="../../types/messaging/Source.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>Source</code></a> to assign to the local end of this <a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionManager</code></a>.

 Must be called during setup, i.e. before calling the <a href="../Endpoint.html#open()"><code>Endpoint.open()</code></a> method.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../TransactionManager.html#setSource(org.apache.qpid.protonj2.types.messaging.Source)">setSource</a></code>&nbsp;in interface&nbsp;<code><a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a></code></dd>
<dt>Parameters:</dt>
<dd><code>source</code> - The <a href="../../types/messaging/Source.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>Source</code></a> that will be set on the local end of this transaction controller.</dd>
<dt>Returns:</dt>
<dd>this transaction controller 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="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionManager</code></a> has already been opened.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getSource()">
<h3>getSource</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../../types/messaging/Source.html" title="class in org.apache.qpid.protonj2.types.messaging">Source</a></span>&nbsp;<span class="element-name">getSource</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../TransactionManager.html#getSource()">getSource</a></code>&nbsp;in interface&nbsp;<code><a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a></code></dd>
<dt>Returns:</dt>
<dd>the <a href="../../types/messaging/Source.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>Source</code></a> for the local end of this <a href="../TransactionController.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionController</code></a>.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setCoordinator(org.apache.qpid.protonj2.types.transactions.Coordinator)">
<h3>setCoordinator</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a></span>&nbsp;<span class="element-name">setCoordinator</span><wbr><span class="parameters">(<a href="../../types/transactions/Coordinator.html" title="class in org.apache.qpid.protonj2.types.transactions">Coordinator</a>&nbsp;coordinator)</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="../TransactionManager.html#setCoordinator(org.apache.qpid.protonj2.types.transactions.Coordinator)">TransactionManager</a></code></span></div>
<div class="block">Sets the <a href="../../types/transactions/Coordinator.html" title="class in org.apache.qpid.protonj2.types.transactions"><code>Coordinator</code></a> target to assign to the local end of this <a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionManager</code></a>.

 Must be called during setup, i.e. before calling the <a href="../Endpoint.html#open()"><code>Endpoint.open()</code></a> method.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../TransactionManager.html#setCoordinator(org.apache.qpid.protonj2.types.transactions.Coordinator)">setCoordinator</a></code>&nbsp;in interface&nbsp;<code><a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a></code></dd>
<dt>Parameters:</dt>
<dd><code>coordinator</code> - The <a href="../../types/transactions/Coordinator.html" title="class in org.apache.qpid.protonj2.types.transactions"><code>Coordinator</code></a> target that will be set on the local end of this transaction controller.</dd>
<dt>Returns:</dt>
<dd>this transaction controller 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="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionManager</code></a> has already been opened.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getCoordinator()">
<h3>getCoordinator</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../../types/transactions/Coordinator.html" title="class in org.apache.qpid.protonj2.types.transactions">Coordinator</a></span>&nbsp;<span class="element-name">getCoordinator</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../TransactionManager.html#getCoordinator()">TransactionManager</a></code></span></div>
<div class="block">Returns the currently set Coordinator target for this <a href="../Link.html" title="interface in org.apache.qpid.protonj2.engine"><code>Link</code></a>.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../TransactionManager.html#getCoordinator()">getCoordinator</a></code>&nbsp;in interface&nbsp;<code><a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a></code></dd>
<dt>Returns:</dt>
<dd>the link target <a href="../../types/transactions/Coordinator.html" title="class in org.apache.qpid.protonj2.types.transactions"><code>Coordinator</code></a> for the local end of this link.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getCondition()">
<h3>getCondition</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../../types/transport/ErrorCondition.html" title="class in org.apache.qpid.protonj2.types.transport">ErrorCondition</a></span>&nbsp;<span class="element-name">getCondition</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Endpoint.html#getCondition()">getCondition</a></code>&nbsp;in interface&nbsp;<code><a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine">Endpoint</a>&lt;<a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a>&gt;</code></dd>
<dt>Overrides:</dt>
<dd><code><a href="ProtonEndpoint.html#getCondition()">getCondition</a></code>&nbsp;in class&nbsp;<code><a href="ProtonEndpoint.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonEndpoint</a>&lt;<a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a>&gt;</code></dd>
<dt>Returns:</dt>
<dd>the local <a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a> error, or null if there is none</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setCondition(org.apache.qpid.protonj2.types.transport.ErrorCondition)">
<h3>setCondition</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a></span>&nbsp;<span class="element-name">setCondition</span><wbr><span class="parameters">(<a href="../../types/transport/ErrorCondition.html" title="class in org.apache.qpid.protonj2.types.transport">ErrorCondition</a>&nbsp;condition)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Endpoint.html#setCondition(org.apache.qpid.protonj2.types.transport.ErrorCondition)">Endpoint</a></code></span></div>
<div class="block">Sets the local <a href="../../types/transport/ErrorCondition.html" title="class in org.apache.qpid.protonj2.types.transport"><code>ErrorCondition</code></a> to be applied to a <a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a> close.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Endpoint.html#setCondition(org.apache.qpid.protonj2.types.transport.ErrorCondition)">setCondition</a></code>&nbsp;in interface&nbsp;<code><a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine">Endpoint</a>&lt;<a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a>&gt;</code></dd>
<dt>Overrides:</dt>
<dd><code><a href="ProtonEndpoint.html#setCondition(org.apache.qpid.protonj2.types.transport.ErrorCondition)">setCondition</a></code>&nbsp;in class&nbsp;<code><a href="ProtonEndpoint.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonEndpoint</a>&lt;<a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a>&gt;</code></dd>
<dt>Parameters:</dt>
<dd><code>condition</code> - The error condition to convey to the remote peer on close of this end point.</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="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</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="setProperties(java.util.Map)">
<h3>setProperties</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</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>
                                 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="../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="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</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>
<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="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a> has already been 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="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</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;offeredCapabilities)</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="../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="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a>&gt;</code></dd>
<dt>Parameters:</dt>
<dd><code>offeredCapabilities</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>
<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="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a> has already been opened.</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="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</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="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</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;desiredCapabilities)</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="../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="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a>&gt;</code></dd>
<dt>Parameters:</dt>
<dd><code>desiredCapabilities</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>
<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="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a> has already been opened.</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="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</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="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="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</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="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</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="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</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="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</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="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</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="getRemoteCondition()">
<h3>getRemoteCondition</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../../types/transport/ErrorCondition.html" title="class in org.apache.qpid.protonj2.types.transport">ErrorCondition</a></span>&nbsp;<span class="element-name">getRemoteCondition</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Endpoint.html#getRemoteCondition()">Endpoint</a></code></span></div>
<div class="block">If the remote has closed this <a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a> and provided an <a href="../../types/transport/ErrorCondition.html" title="class in org.apache.qpid.protonj2.types.transport"><code>ErrorCondition</code></a> as part
 of the closing AMQP performative then this method will return it.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Endpoint.html#getRemoteCondition()">getRemoteCondition</a></code>&nbsp;in interface&nbsp;<code><a href="../Endpoint.html" title="interface in org.apache.qpid.protonj2.engine">Endpoint</a>&lt;<a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a>&gt;</code></dd>
<dt>Overrides:</dt>
<dd><code><a href="ProtonEndpoint.html#getRemoteCondition()">getRemoteCondition</a></code>&nbsp;in class&nbsp;<code><a href="ProtonEndpoint.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonEndpoint</a>&lt;<a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a>&gt;</code></dd>
<dt>Returns:</dt>
<dd>the remote supplied <a href="../../types/transport/ErrorCondition.html" title="class in org.apache.qpid.protonj2.types.transport"><code>ErrorCondition</code></a>, or null if there is none.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getRemoteSource()">
<h3>getRemoteSource</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../../types/messaging/Source.html" title="class in org.apache.qpid.protonj2.types.messaging">Source</a></span>&nbsp;<span class="element-name">getRemoteSource</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../TransactionManager.html#getRemoteSource()">getRemoteSource</a></code>&nbsp;in interface&nbsp;<code><a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a></code></dd>
<dt>Returns:</dt>
<dd>the source <a href="../../types/messaging/Source.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>Source</code></a> for the remote end of this <a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionManager</code></a>.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getRemoteCoordinator()">
<h3>getRemoteCoordinator</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../../types/transactions/Coordinator.html" title="class in org.apache.qpid.protonj2.types.transactions">Coordinator</a></span>&nbsp;<span class="element-name">getRemoteCoordinator</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../TransactionManager.html#getRemoteCoordinator()">TransactionManager</a></code></span></div>
<div class="block">Returns the remote target <a href="../../types/messaging/Terminus.html" title="interface in org.apache.qpid.protonj2.types.messaging"><code>Terminus</code></a> for this transaction manager which must be of type
 <a href="../../types/transactions/Coordinator.html" title="class in org.apache.qpid.protonj2.types.transactions"><code>Coordinator</code></a> or null if remote did not set a terminus.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../TransactionManager.html#getRemoteCoordinator()">getRemoteCoordinator</a></code>&nbsp;in interface&nbsp;<code><a href="../TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a></code></dd>
<dt>Returns:</dt>
<dd>the remote coordinator <a href="../../types/messaging/Terminus.html" title="interface in org.apache.qpid.protonj2.types.messaging"><code>Terminus</code></a> for the remote end of this link.</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>
