<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>TransactionController (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, interface: TransactionController">
<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/TransactionController.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>Field&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method-summary">Method</a></li>
</ul>
<ul class="sub-nav-list">
<li>Detail:&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method-detail">Method</a></li>
</ul>
</div>
</div>
<!-- ========= END OF TOP NAVBAR ========= -->
<span class="skip-nav" id="skip-navbar-top"></span></nav>
</header>
<div class="flex-content">
<main role="main">
<!-- ======== START OF CLASS DATA ======== -->
<div class="header">
<div class="sub-title"><span class="package-label-in-type">Package</span>&nbsp;<a href="package-summary.html">org.apache.qpid.protonj2.engine</a></div>
<h1 title="Interface TransactionController" class="title">Interface TransactionController</h1>
</div>
<section class="class-description" id="class-description">
<dl class="notes">
<dt>All Superinterfaces:</dt>
<dd><code><a href="Endpoint.html" title="interface in org.apache.qpid.protonj2.engine">Endpoint</a>&lt;<a href="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine">TransactionController</a>&gt;</code></dd>
</dl>
<dl class="notes">
<dt>All Known Implementing Classes:</dt>
<dd><code><a href="impl/ProtonTransactionController.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonTransactionController</a></code></dd>
</dl>
<hr>
<div class="type-signature"><span class="modifiers">public interface </span><span class="element-name type-name-label">TransactionController</span><span class="extends-implements">
extends <a href="Endpoint.html" title="interface in org.apache.qpid.protonj2.engine">Endpoint</a>&lt;<a href="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine">TransactionController</a>&gt;</span></div>
<div class="block">Transaction Controller link that implements the mechanics of declaring and discharging
 AMQP transactions.  A <a href="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionController</code></a> is typically used at the client side
 of an AMQP <a href="Link.html" title="interface in org.apache.qpid.protonj2.engine"><code>Link</code></a> to create <a href="Transaction.html" title="interface in org.apache.qpid.protonj2.engine"><code>Transaction</code></a> instances which the client application
 will enlist its incoming and outgoing deliveries into.</div>
</section>
<section class="summary">
<ul class="summary-list">
<!-- ========== 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-tab3" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab3', 3)" class="table-tab">Abstract 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-tab3"><code><a href="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine">TransactionController</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#addCapacityAvailableHandler(org.apache.qpid.protonj2.engine.EventHandler)" class="member-name-link">addCapacityAvailableHandler</a><wbr>(<a href="EventHandler.html" title="interface in org.apache.qpid.protonj2.engine">EventHandler</a>&lt;<a href="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine">TransactionController</a>&gt;&nbsp;handler)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Allows the caller to add an <a href="EventHandler.html" title="interface in org.apache.qpid.protonj2.engine"><code>EventHandler</code></a> that will be signaled when the underlying
 link for this <a href="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionController</code></a> has been granted credit which would then allow for
 transaction <a href="../types/transactions/Declared.html" title="class in org.apache.qpid.protonj2.types.transactions"><code>Declared</code></a> and <a href="../types/transactions/Discharge.html" title="class in org.apache.qpid.protonj2.types.transactions"><code>Discharge</code></a> commands to be sent to the remote Transactional
 Resource.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Transaction.html" title="interface in org.apache.qpid.protonj2.engine">Transaction</a>&lt;<a href="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine">TransactionController</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#declare()" class="member-name-link">declare</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Request that the remote <a href="TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionManager</code></a> declare a new transaction and
 respond with a new transaction Id for that transaction.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine">TransactionController</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#declare(org.apache.qpid.protonj2.engine.Transaction)" class="member-name-link">declare</a><wbr>(<a href="Transaction.html" title="interface in org.apache.qpid.protonj2.engine">Transaction</a>&lt;<a href="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine">TransactionController</a>&gt;&nbsp;transaction)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Request that the remote <a href="TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionManager</code></a> declare a new transaction and
 respond with a new transaction Id for that transaction.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine">TransactionController</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#declaredHandler(org.apache.qpid.protonj2.engine.EventHandler)" class="member-name-link">declaredHandler</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="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine">TransactionController</a>&gt;&gt;&nbsp;declaredEventHandler)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Called when the <a href="TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionManager</code></a> end of the link has responded to a previous
 <a href="../types/transactions/Declare.html" title="class in org.apache.qpid.protonj2.types.transactions"><code>Declare</code></a> request and the transaction can now be used to enroll deliveries into the
 active transaction.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine">TransactionController</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#declareFailureHandler(org.apache.qpid.protonj2.engine.EventHandler)" class="member-name-link">declareFailureHandler</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="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine">TransactionController</a>&gt;&gt;&nbsp;declareFailureEventHandler)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Called when the <a href="TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionManager</code></a> end of the link responds to a <a href="Transaction.html" title="interface in org.apache.qpid.protonj2.engine"><code>Transaction</code></a> declaration
 with an <a href="../types/messaging/Rejected.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>Rejected</code></a> outcome indicating that the transaction could not be successfully declared.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine">TransactionController</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#discharge(org.apache.qpid.protonj2.engine.Transaction,boolean)" class="member-name-link">discharge</a><wbr>(<a href="Transaction.html" title="interface in org.apache.qpid.protonj2.engine">Transaction</a>&lt;<a href="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine">TransactionController</a>&gt;&nbsp;transaction,
 boolean&nbsp;failed)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Request that the remote <a href="TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionManager</code></a> discharge the given transaction and
 with the specified failure state (true for failed).</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine">TransactionController</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#dischargedHandler(org.apache.qpid.protonj2.engine.EventHandler)" class="member-name-link">dischargedHandler</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="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine">TransactionController</a>&gt;&gt;&nbsp;dischargedEventHandler)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Called when the <a href="TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionManager</code></a> end of the link has responded to a previous
 <a href="#discharge(org.apache.qpid.protonj2.engine.Transaction,boolean)"><code>discharge(Transaction, boolean)</code></a> request and the transaction has
 been retired.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine">TransactionController</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#dischargeFailureHandler(org.apache.qpid.protonj2.engine.EventHandler)" class="member-name-link">dischargeFailureHandler</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="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine">TransactionController</a>&gt;&gt;&nbsp;dischargeFailureEventHandler)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Called when the <a href="TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionManager</code></a> end of the link has responded to a previous
 <a href="#discharge(org.apache.qpid.protonj2.engine.Transaction,boolean)"><code>discharge(Transaction, boolean)</code></a> request and the transaction discharge
 failed for some reason.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><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-tab3"><code><a href="#getCoordinator()" class="member-name-link">getCoordinator</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><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-tab3"><code><a href="#getRemoteCoordinator()" class="member-name-link">getRemoteCoordinator</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<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 controller 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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><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-tab3"><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-tab3">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><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-tab3"><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-tab3">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#hasCapacity()" class="member-name-link">hasCapacity</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Returns <code>true</code> if the <a href="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionController</code></a> has capacity to send or buffer
 and <a href="Transaction.html" title="interface in org.apache.qpid.protonj2.engine"><code>Transaction</code></a> command to <a href="../types/transactions/Declare.html" title="class in org.apache.qpid.protonj2.types.transactions"><code>Declare</code></a> or <a href="../types/transactions/Discharge.html" title="class in org.apache.qpid.protonj2.types.transactions"><code>Discharge</code></a>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Transaction.html" title="interface in org.apache.qpid.protonj2.engine">Transaction</a>&lt;<a href="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine">TransactionController</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#newTransaction()" class="member-name-link">newTransaction</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Creates a new <a href="Transaction.html" title="interface in org.apache.qpid.protonj2.engine"><code>Transaction</code></a> instances that is returned in the <a href="TransactionState.html#IDLE"><code>TransactionState.IDLE</code></a> state
 which can be populated with application specific attachments or assigned a linked resource prior to calling
 the</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine">TransactionController</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><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="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine">TransactionController</a>&gt;&nbsp;handler)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<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="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionController</code></a>
 is locally closed.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine">TransactionController</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><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-tab3">
<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="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionController</code></a>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine">TransactionController</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<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="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionController</code></a>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;<a href="Transaction.html" title="interface in org.apache.qpid.protonj2.engine">Transaction</a>&lt;<a href="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine">TransactionController</a>&gt;&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#transactions()" class="member-name-link">transactions</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Returns a list of <a href="Transaction.html" title="interface in org.apache.qpid.protonj2.engine"><code>Transaction</code></a> objects that are active within this <a href="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionController</code></a> which
 have not reached a terminal state meaning they have not been successfully discharged and have not failed in
 either the <a href="../types/transactions/Declare.html" title="class in org.apache.qpid.protonj2.types.transactions"><code>Declare</code></a> phase or the <a href="../types/transactions/Discharge.html" title="class in org.apache.qpid.protonj2.types.transactions"><code>Discharge</code></a> phase.</div>
</div>
</div>
</div>
</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#close()">close</a>, <a href="Endpoint.html#closeHandler(org.apache.qpid.protonj2.engine.EventHandler)">closeHandler</a>, <a href="Endpoint.html#engineShutdownHandler(org.apache.qpid.protonj2.engine.EventHandler)">engineShutdownHandler</a>, <a href="Endpoint.html#getAttachments()">getAttachments</a>, <a href="Endpoint.html#getCondition()">getCondition</a>, <a href="Endpoint.html#getDesiredCapabilities()">getDesiredCapabilities</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#getOfferedCapabilities()">getOfferedCapabilities</a>, <a href="Endpoint.html#getParent()">getParent</a>, <a href="Endpoint.html#getProperties()">getProperties</a>, <a href="Endpoint.html#getRemoteCondition()">getRemoteCondition</a>, <a href="Endpoint.html#getRemoteDesiredCapabilities()">getRemoteDesiredCapabilities</a>, <a href="Endpoint.html#getRemoteOfferedCapabilities()">getRemoteOfferedCapabilities</a>, <a href="Endpoint.html#getRemoteProperties()">getRemoteProperties</a>, <a href="Endpoint.html#isLocallyClosed()">isLocallyClosed</a>, <a href="Endpoint.html#isLocallyOpen()">isLocallyOpen</a>, <a href="Endpoint.html#isRemotelyClosed()">isRemotelyClosed</a>, <a href="Endpoint.html#isRemotelyOpen()">isRemotelyOpen</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#open()">open</a>, <a href="Endpoint.html#openHandler(org.apache.qpid.protonj2.engine.EventHandler)">openHandler</a>, <a href="Endpoint.html#setCondition(org.apache.qpid.protonj2.types.transport.ErrorCondition)">setCondition</a>, <a href="Endpoint.html#setDesiredCapabilities(org.apache.qpid.protonj2.types.Symbol...)">setDesiredCapabilities</a>, <a href="Endpoint.html#setLinkedResource(java.lang.Object)">setLinkedResource</a>, <a href="Endpoint.html#setOfferedCapabilities(org.apache.qpid.protonj2.types.Symbol...)">setOfferedCapabilities</a>, <a href="Endpoint.html#setProperties(java.util.Map)">setProperties</a></code></div>
</section>
</li>
</ul>
</section>
<section class="details">
<ul class="details-list">
<!-- ============ METHOD DETAIL ========== -->
<li>
<section class="method-details" id="method-detail">
<h2>Method Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="hasCapacity()">
<h3>hasCapacity</h3>
<div class="member-signature"><span class="return-type">boolean</span>&nbsp;<span class="element-name">hasCapacity</span>()</div>
<div class="block">Returns <code>true</code> if the <a href="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionController</code></a> has capacity to send or buffer
 and <a href="Transaction.html" title="interface in org.apache.qpid.protonj2.engine"><code>Transaction</code></a> command to <a href="../types/transactions/Declare.html" title="class in org.apache.qpid.protonj2.types.transactions"><code>Declare</code></a> or <a href="../types/transactions/Discharge.html" title="class in org.apache.qpid.protonj2.types.transactions"><code>Discharge</code></a>.  If no capacity then
 a call to <a href="#declare()"><code>declare()</code></a> or to
 <a href="#discharge(org.apache.qpid.protonj2.engine.Transaction,boolean)"><code>discharge(Transaction, boolean)</code></a> would throw an exception.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>true if the controller will allow declaring or discharging a transaction at this time.</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="return-type"><a href="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine">TransactionController</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">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="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionController</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>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="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionController</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="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>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="return-type"><a href="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine">TransactionController</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">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="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionController</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>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="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionController</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="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">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>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="getRemoteSource()">
<h3>getRemoteSource</h3>
<div class="member-signature"><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>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="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionController</code></a>.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getRemoteCoordinator()">
<h3>getRemoteCoordinator</h3>
<div class="member-signature"><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">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 controller 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>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>
<li>
<section class="detail" id="transactions()">
<h3>transactions</h3>
<div class="member-signature"><span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;<a href="Transaction.html" title="interface in org.apache.qpid.protonj2.engine">Transaction</a>&lt;<a href="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine">TransactionController</a>&gt;&gt;</span>&nbsp;<span class="element-name">transactions</span>()</div>
<div class="block">Returns a list of <a href="Transaction.html" title="interface in org.apache.qpid.protonj2.engine"><code>Transaction</code></a> objects that are active within this <a href="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionController</code></a> which
 have not reached a terminal state meaning they have not been successfully discharged and have not failed in
 either the <a href="../types/transactions/Declare.html" title="class in org.apache.qpid.protonj2.types.transactions"><code>Declare</code></a> phase or the <a href="../types/transactions/Discharge.html" title="class in org.apache.qpid.protonj2.types.transactions"><code>Discharge</code></a> phase.  If there are no transactions active within
 this <a href="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionController</code></a> this method returns an empty <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link"><code>Collection</code></a>.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>a list of Transactions that are allocated to this controller that have not reached a terminal state.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="newTransaction()">
<h3>newTransaction</h3>
<div class="member-signature"><span class="return-type"><a href="Transaction.html" title="interface in org.apache.qpid.protonj2.engine">Transaction</a>&lt;<a href="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine">TransactionController</a>&gt;</span>&nbsp;<span class="element-name">newTransaction</span>()</div>
<div class="block">Creates a new <a href="Transaction.html" title="interface in org.apache.qpid.protonj2.engine"><code>Transaction</code></a> instances that is returned in the <a href="TransactionState.html#IDLE"><code>TransactionState.IDLE</code></a> state
 which can be populated with application specific attachments or assigned a linked resource prior to calling
 the</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>a new <a href="Transaction.html" title="interface in org.apache.qpid.protonj2.engine"><code>Transaction</code></a> instance that can be correlated with later declared events.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="declare()">
<h3>declare</h3>
<div class="member-signature"><span class="return-type"><a href="Transaction.html" title="interface in org.apache.qpid.protonj2.engine">Transaction</a>&lt;<a href="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine">TransactionController</a>&gt;</span>&nbsp;<span class="element-name">declare</span>()</div>
<div class="block">Request that the remote <a href="TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionManager</code></a> declare a new transaction and
 respond with a new transaction Id for that transaction.  Upon successful declaration of
 a new transaction the remote will respond and the <a href="#declaredHandler(org.apache.qpid.protonj2.engine.EventHandler)"><code>declaredHandler(EventHandler)</code></a>
 event handler will be signaled.

 This is a convenience method that is the same as first calling <a href="#newTransaction()"><code>newTransaction()</code></a>
 and then passing the result of that to the <a href="#declare(org.apache.qpid.protonj2.engine.Transaction)"><code>declare(Transaction)</code></a> method.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>a new <a href="Transaction.html" title="interface in org.apache.qpid.protonj2.engine"><code>Transaction</code></a> instance that can be correlated with later declared events.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="declare(org.apache.qpid.protonj2.engine.Transaction)">
<h3>declare</h3>
<div class="member-signature"><span class="return-type"><a href="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine">TransactionController</a></span>&nbsp;<span class="element-name">declare</span><wbr><span class="parameters">(<a href="Transaction.html" title="interface in org.apache.qpid.protonj2.engine">Transaction</a>&lt;<a href="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine">TransactionController</a>&gt;&nbsp;transaction)</span></div>
<div class="block">Request that the remote <a href="TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionManager</code></a> declare a new transaction and
 respond with a new transaction Id for that transaction.  Upon successful declaration of
 a new transaction the remote will respond and the <a href="#declaredHandler(org.apache.qpid.protonj2.engine.EventHandler)"><code>declaredHandler(EventHandler)</code></a>
 event handler will be signaled.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>transaction</code> - The <a href="Transaction.html" title="interface in org.apache.qpid.protonj2.engine"><code>Transaction</code></a> that is will be associated with the eventual declared transaction.</dd>
<dt>Returns:</dt>
<dd>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="discharge(org.apache.qpid.protonj2.engine.Transaction,boolean)">
<h3>discharge</h3>
<div class="member-signature"><span class="return-type"><a href="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine">TransactionController</a></span>&nbsp;<span class="element-name">discharge</span><wbr><span class="parameters">(<a href="Transaction.html" title="interface in org.apache.qpid.protonj2.engine">Transaction</a>&lt;<a href="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine">TransactionController</a>&gt;&nbsp;transaction,
 boolean&nbsp;failed)</span></div>
<div class="block">Request that the remote <a href="TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionManager</code></a> discharge the given transaction and
 with the specified failure state (true for failed).  Upon successful declaration of
 a new transaction the remote will respond and the <a href="#declaredHandler(org.apache.qpid.protonj2.engine.EventHandler)"><code>declaredHandler(EventHandler)</code></a>
 event handler will be signaled.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>transaction</code> - The <a href="Transaction.html" title="interface in org.apache.qpid.protonj2.engine"><code>Transaction</code></a> that is being discharged.</dd>
<dd><code>failed</code> - boolean value indicating the the discharge indicates the transaction failed (rolled back).</dd>
<dt>Returns:</dt>
<dd>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="declaredHandler(org.apache.qpid.protonj2.engine.EventHandler)">
<h3>declaredHandler</h3>
<div class="member-signature"><span class="return-type"><a href="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine">TransactionController</a></span>&nbsp;<span class="element-name">declaredHandler</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="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine">TransactionController</a>&gt;&gt;&nbsp;declaredEventHandler)</span></div>
<div class="block">Called when the <a href="TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionManager</code></a> end of the link has responded to a previous
 <a href="../types/transactions/Declare.html" title="class in org.apache.qpid.protonj2.types.transactions"><code>Declare</code></a> request and the transaction can now be used to enroll deliveries into the
 active transaction.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>declaredEventHandler</code> - An <a href="EventHandler.html" title="interface in org.apache.qpid.protonj2.engine"><code>EventHandler</code></a> that will act on the transaction declaration request.</dd>
<dt>Returns:</dt>
<dd>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="declareFailureHandler(org.apache.qpid.protonj2.engine.EventHandler)">
<h3>declareFailureHandler</h3>
<div class="member-signature"><span class="return-type"><a href="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine">TransactionController</a></span>&nbsp;<span class="element-name">declareFailureHandler</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="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine">TransactionController</a>&gt;&gt;&nbsp;declareFailureEventHandler)</span></div>
<div class="block">Called when the <a href="TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionManager</code></a> end of the link responds to a <a href="Transaction.html" title="interface in org.apache.qpid.protonj2.engine"><code>Transaction</code></a> declaration
 with an <a href="../types/messaging/Rejected.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>Rejected</code></a> outcome indicating that the transaction could not be successfully declared.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>declareFailureEventHandler</code> - An <a href="EventHandler.html" title="interface in org.apache.qpid.protonj2.engine"><code>EventHandler</code></a> that will be called when a previous transaction declaration fails.</dd>
<dt>Returns:</dt>
<dd>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="dischargedHandler(org.apache.qpid.protonj2.engine.EventHandler)">
<h3>dischargedHandler</h3>
<div class="member-signature"><span class="return-type"><a href="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine">TransactionController</a></span>&nbsp;<span class="element-name">dischargedHandler</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="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine">TransactionController</a>&gt;&gt;&nbsp;dischargedEventHandler)</span></div>
<div class="block">Called when the <a href="TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionManager</code></a> end of the link has responded to a previous
 <a href="#discharge(org.apache.qpid.protonj2.engine.Transaction,boolean)"><code>discharge(Transaction, boolean)</code></a> request and the transaction has
 been retired.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>dischargedEventHandler</code> - An <a href="EventHandler.html" title="interface in org.apache.qpid.protonj2.engine"><code>EventHandler</code></a> that will act on the transaction discharge request.</dd>
<dt>Returns:</dt>
<dd>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="dischargeFailureHandler(org.apache.qpid.protonj2.engine.EventHandler)">
<h3>dischargeFailureHandler</h3>
<div class="member-signature"><span class="return-type"><a href="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine">TransactionController</a></span>&nbsp;<span class="element-name">dischargeFailureHandler</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="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine">TransactionController</a>&gt;&gt;&nbsp;dischargeFailureEventHandler)</span></div>
<div class="block">Called when the <a href="TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionManager</code></a> end of the link has responded to a previous
 <a href="#discharge(org.apache.qpid.protonj2.engine.Transaction,boolean)"><code>discharge(Transaction, boolean)</code></a> request and the transaction discharge
 failed for some reason.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>dischargeFailureEventHandler</code> - An <a href="EventHandler.html" title="interface in org.apache.qpid.protonj2.engine"><code>EventHandler</code></a> that will act on the transaction discharge failed event.</dd>
<dt>Returns:</dt>
<dd>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="addCapacityAvailableHandler(org.apache.qpid.protonj2.engine.EventHandler)">
<h3>addCapacityAvailableHandler</h3>
<div class="member-signature"><span class="return-type"><a href="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine">TransactionController</a></span>&nbsp;<span class="element-name">addCapacityAvailableHandler</span><wbr><span class="parameters">(<a href="EventHandler.html" title="interface in org.apache.qpid.protonj2.engine">EventHandler</a>&lt;<a href="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine">TransactionController</a>&gt;&nbsp;handler)</span></div>
<div class="block">Allows the caller to add an <a href="EventHandler.html" title="interface in org.apache.qpid.protonj2.engine"><code>EventHandler</code></a> that will be signaled when the underlying
 link for this <a href="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionController</code></a> has been granted credit which would then allow for
 transaction <a href="../types/transactions/Declared.html" title="class in org.apache.qpid.protonj2.types.transactions"><code>Declared</code></a> and <a href="../types/transactions/Discharge.html" title="class in org.apache.qpid.protonj2.types.transactions"><code>Discharge</code></a> commands to be sent to the remote Transactional
 Resource.

 If the controller already has credit to send then the handler will be invoked immediately otherwise
 it will be stored until credit becomes available.  Once a handler is signaled it is no longer retained
 for future updates and the caller will need to register it again once more transactional work is to be
 completed.  Because more than one handler can be added at a time the caller should check again before
 attempting to perform a transaction <a href="../types/transactions/Declared.html" title="class in org.apache.qpid.protonj2.types.transactions"><code>Declared</code></a> or <a href="../types/transactions/Discharge.html" title="class in org.apache.qpid.protonj2.types.transactions"><code>Discharge</code></a> is performed as other tasks
 might have already consumed credit if work is done via some asynchronous mechanism.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>handler</code> - The <a href="EventHandler.html" title="interface in org.apache.qpid.protonj2.engine"><code>EventHandler</code></a> that will be signaled once credit is available for transaction work.</dd>
<dt>Returns:</dt>
<dd>this <a href="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionController</code></a> instance.</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="return-type"><a href="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine">TransactionController</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="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine">TransactionController</a>&gt;&nbsp;handler)</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="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionController</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>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 controller's parent endpoint is locally closed.</dd>
<dt>Returns:</dt>
<dd>the link for chaining.</dd>
</dl>
</section>
</li>
</ul>
</section>
</li>
</ul>
</section>
<!-- ========= END OF CLASS DATA ========= -->
</main>
<footer role="contentinfo">
<hr>
<p class="legal-copy"><small>Copyright &#169; 2023 <a href="https://www.apache.org/">The Apache Software Foundation</a>. All rights reserved.</small></p>
</footer>
</div>
</div>
</body>
</html>
