<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>Link (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: Link">
<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/Link.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 Link" class="title">Interface Link&lt;L extends Link&lt;L&gt;&gt;</h1>
</div>
<section class="class-description" id="class-description">
<dl class="notes">
<dt>Type Parameters:</dt>
<dd><code>L</code> - The link type that this <a href="Link.html" title="interface in org.apache.qpid.protonj2.engine"><code>Link</code></a> represents, <a href="Sender.html" title="interface in org.apache.qpid.protonj2.engine"><code>Sender</code></a> or <a href="Receiver.html" title="interface in org.apache.qpid.protonj2.engine"><code>Receiver</code></a></dd>
</dl>
<dl class="notes">
<dt>All Superinterfaces:</dt>
<dd><code><a href="Endpoint.html" title="interface in org.apache.qpid.protonj2.engine">Endpoint</a>&lt;L&gt;</code></dd>
</dl>
<dl class="notes">
<dt>All Known Subinterfaces:</dt>
<dd><code><a href="Receiver.html" title="interface in org.apache.qpid.protonj2.engine">Receiver</a></code>, <code><a href="Sender.html" title="interface in org.apache.qpid.protonj2.engine">Sender</a></code></dd>
</dl>
<dl class="notes">
<dt>All Known Implementing Classes:</dt>
<dd><code><a href="impl/ProtonLink.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonLink</a></code>, <code><a href="impl/ProtonReceiver.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonReceiver</a></code>, <code><a href="impl/ProtonSender.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonSender</a></code></dd>
</dl>
<hr>
<div class="type-signature"><span class="modifiers">public interface </span><span class="element-name type-name-label">Link&lt;L extends Link&lt;L&gt;&gt;</span><span class="extends-implements">
extends <a href="Endpoint.html" title="interface in org.apache.qpid.protonj2.engine">Endpoint</a>&lt;L&gt;</span></div>
<div class="block">Base API for <a href="Sender.html" title="interface in org.apache.qpid.protonj2.engine"><code>Sender</code></a> and <a href="Receiver.html" title="interface in org.apache.qpid.protonj2.engine"><code>Receiver</code></a> links.</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="Link.html" title="type parameter in Link">L</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#creditStateUpdateHandler(org.apache.qpid.protonj2.engine.EventHandler)" class="member-name-link">creditStateUpdateHandler</a><wbr>(<a href="EventHandler.html" title="interface in org.apache.qpid.protonj2.engine">EventHandler</a>&lt;<a href="Link.html" title="type parameter in Link">L</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">Handler for link credit updates that occur after a remote <a href="../types/transport/Flow.html" title="class in org.apache.qpid.protonj2.types.transport"><code>Flow</code></a> arrives.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Link.html" title="type parameter in Link">L</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#detach()" class="member-name-link">detach</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Detach this end of the link.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Link.html" title="type parameter in Link">L</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#detachHandler(org.apache.qpid.protonj2.engine.EventHandler)" class="member-name-link">detachHandler</a><wbr>(<a href="EventHandler.html" title="interface in org.apache.qpid.protonj2.engine">EventHandler</a>&lt;<a href="Link.html" title="type parameter in Link">L</a>&gt;&nbsp;remoteDetachHandler)</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 an AMQP Detach frame is received from the remote peer for this
 <a href="Link.html" title="interface in org.apache.qpid.protonj2.engine"><code>Link</code></a> which would have been locally opened previously, the Detach from would have been marked
 as not having been closed.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#getConnection()" class="member-name-link">getConnection</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><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-tab3">
<div class="block">Get the credit that is currently available or assigned to this link.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="../types/UnsignedLong.html" title="class in org.apache.qpid.protonj2.types">UnsignedLong</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#getMaxMessageSize()" class="member-name-link">getMaxMessageSize</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Gets the local link max message size.</div>
</div>
<div class="col-first even-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/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#getName()" class="member-name-link">getName</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="Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><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-tab3">
<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-tab3"><code><a href="../types/transport/ReceiverSettleMode.html" title="enum in org.apache.qpid.protonj2.types.transport">ReceiverSettleMode</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#getReceiverSettleMode()" class="member-name-link">getReceiverSettleMode</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Gets the local link receiver settlement mode.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="../types/UnsignedLong.html" title="class in org.apache.qpid.protonj2.types">UnsignedLong</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#getRemoteMaxMessageSize()" class="member-name-link">getRemoteMaxMessageSize</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Gets the remote link max message size, as conveyed from the peer via the Attach frame
 when attaching the link to the session.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="../types/transport/ReceiverSettleMode.html" title="enum in org.apache.qpid.protonj2.types.transport">ReceiverSettleMode</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#getRemoteReceiverSettleMode()" class="member-name-link">getRemoteReceiverSettleMode</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Gets the remote link receiver settlement mode, as conveyed from the peer via the Attach frame
 when attaching the link to the session.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="../types/transport/SenderSettleMode.html" title="enum in org.apache.qpid.protonj2.types.transport">SenderSettleMode</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#getRemoteSenderSettleMode()" class="member-name-link">getRemoteSenderSettleMode</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Gets the remote link sender settlement mode, as conveyed from the peer via the Attach frame
 when attaching the link to the session.</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="LinkState.html" title="enum in org.apache.qpid.protonj2.engine">LinkState</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#getRemoteState()" class="member-name-link">getRemoteState</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>&lt;T extends <a href="../types/messaging/Terminus.html" title="interface in org.apache.qpid.protonj2.types.messaging">Terminus</a>&gt;<br>T</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#getRemoteTarget()" class="member-name-link">getRemoteTarget</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 remote target <a href="../types/messaging/Terminus.html" title="interface in org.apache.qpid.protonj2.types.messaging"><code>Terminus</code></a> cast to the given type.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="../types/transport/Role.html" title="enum in org.apache.qpid.protonj2.types.transport">Role</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#getRole()" class="member-name-link">getRole</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><a href="../types/transport/SenderSettleMode.html" title="enum in org.apache.qpid.protonj2.types.transport">SenderSettleMode</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#getSenderSettleMode()" class="member-name-link">getSenderSettleMode</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Gets the local link sender settlement mode.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#getSession()" class="member-name-link">getSession</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><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="#getSource()" class="member-name-link">getSource</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="LinkState.html" title="enum in org.apache.qpid.protonj2.engine">LinkState</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#getState()" class="member-name-link">getState</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>&lt;T extends <a href="../types/messaging/Terminus.html" title="interface in org.apache.qpid.protonj2.types.messaging">Terminus</a>&gt;<br>T</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#getTarget()" class="member-name-link">getTarget</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 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>boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#isDraining()" class="member-name-link">isDraining</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Indicates if the link is draining.</div>
</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="#isLocallyClosedOrDetached()" class="member-name-link">isLocallyClosedOrDetached</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 true if this <a href="Link.html" title="interface in org.apache.qpid.protonj2.engine"><code>Link</code></a> is currently locally detached or locally closed meaning the
 state returned from <a href="#getState()"><code>getState()</code></a> is equal to <a href="LinkState.html#DETACHED"><code>LinkState.DETACHED</code></a> or
 <a href="LinkState.html#CLOSED"><code>LinkState.CLOSED</code></a>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#isLocallyDetached()" class="member-name-link">isLocallyDetached</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 true if this <a href="Link.html" title="interface in org.apache.qpid.protonj2.engine"><code>Link</code></a> is currently locally detached meaning the state returned
 from <a href="#getState()"><code>getState()</code></a> is equal to <a href="LinkState.html#DETACHED"><code>LinkState.DETACHED</code></a>.</div>
</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="#isReceiver()" class="member-name-link">isReceiver</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>boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#isRemotelyClosed()" class="member-name-link">isRemotelyClosed</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 true if this <a href="Link.html" title="interface in org.apache.qpid.protonj2.engine"><code>Link</code></a> is currently remotely closed meaning the state returned
 from <a href="#getRemoteState()"><code>getRemoteState()</code></a> is equal to <a href="LinkState.html#CLOSED"><code>LinkState.CLOSED</code></a>.</div>
</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="#isRemotelyClosedOrDetached()" class="member-name-link">isRemotelyClosedOrDetached</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 true if this <a href="Link.html" title="interface in org.apache.qpid.protonj2.engine"><code>Link</code></a> is currently remotely detached or closed meaning the state
 returned from <a href="#getRemoteState()"><code>getRemoteState()</code></a> is equal to <a href="LinkState.html#DETACHED"><code>LinkState.DETACHED</code></a> or
 <a href="LinkState.html#CLOSED"><code>LinkState.CLOSED</code></a>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#isRemotelyDetached()" class="member-name-link">isRemotelyDetached</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 true if this <a href="Link.html" title="interface in org.apache.qpid.protonj2.engine"><code>Link</code></a> is currently remotely detached meaning the state returned
 from <a href="#getRemoteState()"><code>getRemoteState()</code></a> is equal to <a href="LinkState.html#DETACHED"><code>LinkState.DETACHED</code></a>.</div>
</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="#isRemotelyOpen()" class="member-name-link">isRemotelyOpen</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 true if this <a href="Link.html" title="interface in org.apache.qpid.protonj2.engine"><code>Link</code></a> is currently remotely open meaning the state returned
 from <a href="#getRemoteState()"><code>getRemoteState()</code></a> is equal to <a href="LinkState.html#ACTIVE"><code>LinkState.ACTIVE</code></a>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#isSender()" class="member-name-link">isSender</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><a href="Link.html" title="type parameter in Link">L</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#localDetachHandler(org.apache.qpid.protonj2.engine.EventHandler)" class="member-name-link">localDetachHandler</a><wbr>(<a href="EventHandler.html" title="interface in org.apache.qpid.protonj2.engine">EventHandler</a>&lt;<a href="Link.html" title="type parameter in Link">L</a>&gt;&nbsp;localDetachHandler)</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 an this link is detached locally via a call to <a href="#detach()"><code>detach()</code></a>

 This is a convenience event that supplements the normal <a href="Endpoint.html#localCloseHandler(org.apache.qpid.protonj2.engine.EventHandler)"><code>Endpoint.localCloseHandler(EventHandler)</code></a>
 event point if set.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Link.html" title="type parameter in Link">L</a></code></div>
<div class="col-second odd-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="Link.html" title="type parameter in Link">L</a>&gt;&nbsp;handler)</code></div>
<div class="col-last odd-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 link is
 locally closed.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Link.html" title="type parameter in Link">L</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#setMaxMessageSize(org.apache.qpid.protonj2.types.UnsignedLong)" class="member-name-link">setMaxMessageSize</a><wbr>(<a href="../types/UnsignedLong.html" title="class in org.apache.qpid.protonj2.types">UnsignedLong</a>&nbsp;maxMessageSize)</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 local link max message size, to be conveyed to the peer via the Attach frame
 when attaching the link to the session.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Link.html" title="type parameter in Link">L</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#setReceiverSettleMode(org.apache.qpid.protonj2.types.transport.ReceiverSettleMode)" class="member-name-link">setReceiverSettleMode</a><wbr>(<a href="../types/transport/ReceiverSettleMode.html" title="enum in org.apache.qpid.protonj2.types.transport">ReceiverSettleMode</a>&nbsp;receiverSettleMode)</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 receiver settle mode.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Link.html" title="type parameter in Link">L</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#setSenderSettleMode(org.apache.qpid.protonj2.types.transport.SenderSettleMode)" class="member-name-link">setSenderSettleMode</a><wbr>(<a href="../types/transport/SenderSettleMode.html" title="enum in org.apache.qpid.protonj2.types.transport">SenderSettleMode</a>&nbsp;senderSettleMode)</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 sender settle mode.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Link.html" title="type parameter in Link">L</a></code></div>
<div class="col-second odd-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 odd-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="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-tab3"><code><a href="Link.html" title="type parameter in Link">L</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#setTarget(org.apache.qpid.protonj2.types.messaging.Target)" class="member-name-link">setTarget</a><wbr>(<a href="../types/messaging/Target.html" title="class in org.apache.qpid.protonj2.types.messaging">Target</a>&nbsp;target)</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/Target.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>Target</code></a> to assign to the local end of 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="Link.html" title="type parameter in Link">L</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#setTarget(org.apache.qpid.protonj2.types.transactions.Coordinator)" class="member-name-link">setTarget</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="Link.html" title="interface in org.apache.qpid.protonj2.engine"><code>Link</code></a>.</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#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#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="detach()">
<h3>detach</h3>
<div class="member-signature"><span class="return-type"><a href="Link.html" title="type parameter in Link">L</a></span>&nbsp;<span class="element-name">detach</span>()</div>
<div class="block">Detach this end of the link.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>this Link.</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 detaching the <a href="Link.html" title="interface in org.apache.qpid.protonj2.engine"><code>Link</code></a> or the Engine is shutdown.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="isLocallyDetached()">
<h3>isLocallyDetached</h3>
<div class="member-signature"><span class="return-type">boolean</span>&nbsp;<span class="element-name">isLocallyDetached</span>()</div>
<div class="block">Returns true if this <a href="Link.html" title="interface in org.apache.qpid.protonj2.engine"><code>Link</code></a> is currently locally detached meaning the state returned
 from <a href="#getState()"><code>getState()</code></a> is equal to <a href="LinkState.html#DETACHED"><code>LinkState.DETACHED</code></a>.  A link
 is locally detached after a call to <a href="#detach()"><code>detach()</code></a>.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>true if the link 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>
<li><a href="Endpoint.html#isLocallyClosed()"><code>Endpoint.isLocallyClosed()</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="isLocallyClosedOrDetached()">
<h3>isLocallyClosedOrDetached</h3>
<div class="member-signature"><span class="return-type">boolean</span>&nbsp;<span class="element-name">isLocallyClosedOrDetached</span>()</div>
<div class="block">Returns true if this <a href="Link.html" title="interface in org.apache.qpid.protonj2.engine"><code>Link</code></a> is currently locally detached or locally closed meaning the
 state returned from <a href="#getState()"><code>getState()</code></a> is equal to <a href="LinkState.html#DETACHED"><code>LinkState.DETACHED</code></a> or
 <a href="LinkState.html#CLOSED"><code>LinkState.CLOSED</code></a>.  A link is locally detached after a call to <a href="#detach()"><code>detach()</code></a> and
 is locally closed after a call to <a href="Endpoint.html#close()"><code>Endpoint.close()</code></a>.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>true if the link is locally closed or detached.</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="Endpoint.html#isLocallyOpen()"><code>Endpoint.isLocallyOpen()</code></a></li>
<li><a href="#isLocallyDetached()"><code>isLocallyDetached()</code></a></li>
<li><a href="Endpoint.html#isLocallyClosed()"><code>Endpoint.isLocallyClosed()</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getState()">
<h3>getState</h3>
<div class="member-signature"><span class="return-type"><a href="LinkState.html" title="enum in org.apache.qpid.protonj2.engine">LinkState</a></span>&nbsp;<span class="element-name">getState</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the local link state</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getCredit()">
<h3>getCredit</h3>
<div class="member-signature"><span class="return-type">int</span>&nbsp;<span class="element-name">getCredit</span>()</div>
<div class="block">Get the credit that is currently available or assigned to this link.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the current link credit.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="isDraining()">
<h3>isDraining</h3>
<div class="member-signature"><span class="return-type">boolean</span>&nbsp;<span class="element-name">isDraining</span>()</div>
<div class="block">Indicates if the link is draining. For a <a href="Sender.html" title="interface in org.apache.qpid.protonj2.engine"><code>Sender</code></a> link this indicates that the
 remote has requested that the Sender transmit deliveries up to the currently available
 credit or indicate that it has no more to send.  For a <a href="Receiver.html" title="interface in org.apache.qpid.protonj2.engine"><code>Receiver</code></a> this indicates
 that the Receiver has requested that the Sender consume its outstanding credit.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>true if the <a href="Link.html" title="interface in org.apache.qpid.protonj2.engine"><code>Link</code></a> is currently marked as draining.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getRole()">
<h3>getRole</h3>
<div class="member-signature"><span class="return-type"><a href="../types/transport/Role.html" title="enum in org.apache.qpid.protonj2.types.transport">Role</a></span>&nbsp;<span class="element-name">getRole</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the <a href="../types/transport/Role.html" title="enum in org.apache.qpid.protonj2.types.transport"><code>Role</code></a> that this end of the link is performing.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="isSender()">
<h3>isSender</h3>
<div class="member-signature"><span class="return-type">boolean</span>&nbsp;<span class="element-name">isSender</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>true if this link is acting in a sender <a href="../types/transport/Role.html" title="enum in org.apache.qpid.protonj2.types.transport"><code>Role</code></a>.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="isReceiver()">
<h3>isReceiver</h3>
<div class="member-signature"><span class="return-type">boolean</span>&nbsp;<span class="element-name">isReceiver</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>true if this link is acting in a receiver <a href="../types/transport/Role.html" title="enum in org.apache.qpid.protonj2.types.transport"><code>Role</code></a>.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getConnection()">
<h3>getConnection</h3>
<div class="member-signature"><span class="return-type"><a href="Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></span>&nbsp;<span class="element-name">getConnection</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the parent <a href="Connection.html" title="interface in org.apache.qpid.protonj2.engine"><code>Connection</code></a> for the <a href="Link.html" title="interface in org.apache.qpid.protonj2.engine"><code>Link</code></a></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getSession()">
<h3>getSession</h3>
<div class="member-signature"><span class="return-type"><a href="Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</a></span>&nbsp;<span class="element-name">getSession</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the parent <a href="Session.html" title="interface in org.apache.qpid.protonj2.engine"><code>Session</code></a> of the <a href="Link.html" title="interface in org.apache.qpid.protonj2.engine"><code>Link</code></a></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getParent()">
<h3>getParent</h3>
<div class="member-signature"><span class="return-type"><a href="Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</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="Link.html" title="type parameter in Link">L</a> extends <a href="Link.html" title="interface in org.apache.qpid.protonj2.engine">Link</a>&lt;<a href="Link.html" title="type parameter in Link">L</a>&gt;&gt;</code></dd>
<dt>Returns:</dt>
<dd>the parent <a href="Session.html" title="interface in org.apache.qpid.protonj2.engine"><code>Session</code></a> of the <a href="Link.html" title="interface in org.apache.qpid.protonj2.engine"><code>Link</code></a></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getName()">
<h3>getName</h3>
<div class="member-signature"><span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">getName</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the link name that is assigned to this <a href="Link.html" title="interface in org.apache.qpid.protonj2.engine"><code>Link</code></a></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setSenderSettleMode(org.apache.qpid.protonj2.types.transport.SenderSettleMode)">
<h3>setSenderSettleMode</h3>
<div class="member-signature"><span class="return-type"><a href="Link.html" title="type parameter in Link">L</a></span>&nbsp;<span class="element-name">setSenderSettleMode</span><wbr><span class="parameters">(<a href="../types/transport/SenderSettleMode.html" title="enum in org.apache.qpid.protonj2.types.transport">SenderSettleMode</a>&nbsp;senderSettleMode)</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 sender settle mode.
 <p>
 Should only be called during link set-up, i.e. before calling <a href="Endpoint.html#open()"><code>Endpoint.open()</code></a>. If this endpoint is the
 initiator of the link, this method can be used to set a value other than the default.
 <p>
 If this endpoint is not the initiator, this method should be used to set a local value. According
 to the AMQP spec, the application may choose to accept the sender's suggestion
 (accessed by calling <a href="#getRemoteSenderSettleMode()"><code>getRemoteSenderSettleMode()</code></a>) or choose another value. The value
 has no effect on Proton, but may be useful to the application at a later point.
 <p>
 In order to be AMQP compliant the application is responsible for honoring the settlement mode. See <a href="Link.html" title="interface in org.apache.qpid.protonj2.engine"><code>Link</code></a>.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>senderSettleMode</code> - The <a href="../types/transport/SenderSettleMode.html" title="enum in org.apache.qpid.protonj2.types.transport"><code>SenderSettleMode</code></a> that will be set on the local end of this link.</dd>
<dt>Returns:</dt>
<dd>this Link.</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="Link.html" title="interface in org.apache.qpid.protonj2.engine"><code>Link</code></a> has already been opened.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getSenderSettleMode()">
<h3>getSenderSettleMode</h3>
<div class="member-signature"><span class="return-type"><a href="../types/transport/SenderSettleMode.html" title="enum in org.apache.qpid.protonj2.types.transport">SenderSettleMode</a></span>&nbsp;<span class="element-name">getSenderSettleMode</span>()</div>
<div class="block">Gets the local link sender settlement mode.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the local sender settlement mode, or null if none was set.</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list-long">
<li><a href="#setSenderSettleMode(org.apache.qpid.protonj2.types.transport.SenderSettleMode)"><code>setSenderSettleMode(SenderSettleMode)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setReceiverSettleMode(org.apache.qpid.protonj2.types.transport.ReceiverSettleMode)">
<h3>setReceiverSettleMode</h3>
<div class="member-signature"><span class="return-type"><a href="Link.html" title="type parameter in Link">L</a></span>&nbsp;<span class="element-name">setReceiverSettleMode</span><wbr><span class="parameters">(<a href="../types/transport/ReceiverSettleMode.html" title="enum in org.apache.qpid.protonj2.types.transport">ReceiverSettleMode</a>&nbsp;receiverSettleMode)</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 receiver settle mode.
 <p>
 Should only be called during link set-up, i.e. before calling <a href="Endpoint.html#open()"><code>Endpoint.open()</code></a>. If this endpoint
 is the initiator of the link, this method can be used to set a value other than the default.

 Used in analogous way to <a href="#setSenderSettleMode(org.apache.qpid.protonj2.types.transport.SenderSettleMode)"><code>setSenderSettleMode(SenderSettleMode)</code></a></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>receiverSettleMode</code> - The <a href="../types/transport/ReceiverSettleMode.html" title="enum in org.apache.qpid.protonj2.types.transport"><code>ReceiverSettleMode</code></a> that will be set on the local end of this link.</dd>
<dt>Returns:</dt>
<dd>this Link.</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="Link.html" title="interface in org.apache.qpid.protonj2.engine"><code>Link</code></a> has already been opened.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getReceiverSettleMode()">
<h3>getReceiverSettleMode</h3>
<div class="member-signature"><span class="return-type"><a href="../types/transport/ReceiverSettleMode.html" title="enum in org.apache.qpid.protonj2.types.transport">ReceiverSettleMode</a></span>&nbsp;<span class="element-name">getReceiverSettleMode</span>()</div>
<div class="block">Gets the local link receiver settlement mode.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the local receiver settlement mode, or null if none was set.</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list-long">
<li><a href="#setReceiverSettleMode(org.apache.qpid.protonj2.types.transport.ReceiverSettleMode)"><code>setReceiverSettleMode(ReceiverSettleMode)</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="return-type"><a href="Link.html" title="type parameter in Link">L</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="Link.html" title="interface in org.apache.qpid.protonj2.engine"><code>Link</code></a>.
 <p>
 Must be called during link 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 link.</dd>
<dt>Returns:</dt>
<dd>this Link.</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="Link.html" title="interface in org.apache.qpid.protonj2.engine"><code>Link</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 link.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setTarget(org.apache.qpid.protonj2.types.messaging.Target)">
<h3>setTarget</h3>
<div class="member-signature"><span class="return-type"><a href="Link.html" title="type parameter in Link">L</a></span>&nbsp;<span class="element-name">setTarget</span><wbr><span class="parameters">(<a href="../types/messaging/Target.html" title="class in org.apache.qpid.protonj2.types.messaging">Target</a>&nbsp;target)</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/Target.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>Target</code></a> to assign to the local end of this <a href="Link.html" title="interface in org.apache.qpid.protonj2.engine"><code>Link</code></a>.

 Must be called during link 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>target</code> - The <a href="../types/messaging/Target.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>Target</code></a> that will be set on the local end of this link.</dd>
<dt>Returns:</dt>
<dd>this Link.</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="Link.html" title="interface in org.apache.qpid.protonj2.engine"><code>Link</code></a> has already been opened.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setTarget(org.apache.qpid.protonj2.types.transactions.Coordinator)">
<h3>setTarget</h3>
<div class="member-signature"><span class="return-type"><a href="Link.html" title="type parameter in Link">L</a></span>&nbsp;<span class="element-name">setTarget</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="Link.html" title="interface in org.apache.qpid.protonj2.engine"><code>Link</code></a>.
 <p>
 Must be called during link 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 link.</dd>
<dt>Returns:</dt>
<dd>this Link.</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="Link.html" title="interface in org.apache.qpid.protonj2.engine"><code>Link</code></a> has already been opened.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getTarget()">
<h3>getTarget</h3>
<div class="member-signature"><span class="type-parameters">&lt;T extends <a href="../types/messaging/Terminus.html" title="interface in org.apache.qpid.protonj2.types.messaging">Terminus</a>&gt;</span>&nbsp;<span class="return-type">T</span>&nbsp;<span class="element-name">getTarget</span>()</div>
<div class="block">Returns the currently set Target for this <a href="Link.html" title="interface in org.apache.qpid.protonj2.engine"><code>Link</code></a>.  A link target can be either
 a <a href="../types/messaging/Target.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>Target</code></a> type for a <a href="Sender.html" title="interface in org.apache.qpid.protonj2.engine"><code>Sender</code></a> or <a href="Receiver.html" title="interface in org.apache.qpid.protonj2.engine"><code>Receiver</code></a> link or if the link is
 to be transaction resource then the target type will be a <a href="../types/transactions/Coordinator.html" title="class in org.apache.qpid.protonj2.types.transactions"><code>Coordinator</code></a> instance.</div>
<dl class="notes">
<dt>Type Parameters:</dt>
<dd><code>T</code> - The terminus type that the target should be cast to on return.</dd>
<dt>Returns:</dt>
<dd>the link target <a href="../types/messaging/Terminus.html" title="interface in org.apache.qpid.protonj2.types.messaging"><code>Terminus</code></a> for the local end of this link.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setMaxMessageSize(org.apache.qpid.protonj2.types.UnsignedLong)">
<h3>setMaxMessageSize</h3>
<div class="member-signature"><span class="return-type"><a href="Link.html" title="type parameter in Link">L</a></span>&nbsp;<span class="element-name">setMaxMessageSize</span><wbr><span class="parameters">(<a href="../types/UnsignedLong.html" title="class in org.apache.qpid.protonj2.types">UnsignedLong</a>&nbsp;maxMessageSize)</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 local link max message size, to be conveyed to the peer via the Attach frame
 when attaching the link to the session. Null or 0 means no limit.
 <p>
 Must be called during link 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>maxMessageSize</code> - the local max message size value, or null to clear. 0 also means no limit.</dd>
<dt>Returns:</dt>
<dd>this Link.</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="Link.html" title="interface in org.apache.qpid.protonj2.engine"><code>Link</code></a> has already been opened.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getMaxMessageSize()">
<h3>getMaxMessageSize</h3>
<div class="member-signature"><span class="return-type"><a href="../types/UnsignedLong.html" title="class in org.apache.qpid.protonj2.types">UnsignedLong</a></span>&nbsp;<span class="element-name">getMaxMessageSize</span>()</div>
<div class="block">Gets the local link max message size.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the local max message size, or null if none was set. 0 also means no limit.</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list-long">
<li><a href="#setMaxMessageSize(org.apache.qpid.protonj2.types.UnsignedLong)"><code>setMaxMessageSize(UnsignedLong)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="isRemotelyOpen()">
<h3>isRemotelyOpen</h3>
<div class="member-signature"><span class="return-type">boolean</span>&nbsp;<span class="element-name">isRemotelyOpen</span>()</div>
<div class="block">Returns true if this <a href="Link.html" title="interface in org.apache.qpid.protonj2.engine"><code>Link</code></a> is currently remotely open meaning the state returned
 from <a href="#getRemoteState()"><code>getRemoteState()</code></a> is equal to <a href="LinkState.html#ACTIVE"><code>LinkState.ACTIVE</code></a>.  A link
 is remotely opened after an <a href="../types/transport/Attach.html" title="class in org.apache.qpid.protonj2.types.transport"><code>Attach</code></a> has been received from the remote and before a
 <a href="../types/transport/Detach.html" title="class in org.apache.qpid.protonj2.types.transport"><code>Detach</code></a> has been received from the remote.</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="Link.html" title="type parameter in Link">L</a> extends <a href="Link.html" title="interface in org.apache.qpid.protonj2.engine">Link</a>&lt;<a href="Link.html" title="type parameter in Link">L</a>&gt;&gt;</code></dd>
<dt>Returns:</dt>
<dd>true if the link is remotely open.</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="#isRemotelyClosed()"><code>isRemotelyClosed()</code></a></li>
<li><a href="#isRemotelyDetached()"><code>isRemotelyDetached()</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="isRemotelyClosed()">
<h3>isRemotelyClosed</h3>
<div class="member-signature"><span class="return-type">boolean</span>&nbsp;<span class="element-name">isRemotelyClosed</span>()</div>
<div class="block">Returns true if this <a href="Link.html" title="interface in org.apache.qpid.protonj2.engine"><code>Link</code></a> is currently remotely closed meaning the state returned
 from <a href="#getRemoteState()"><code>getRemoteState()</code></a> is equal to <a href="LinkState.html#CLOSED"><code>LinkState.CLOSED</code></a>.  A link
 is remotely closed after an <a href="../types/transport/Detach.html" title="class in org.apache.qpid.protonj2.types.transport"><code>Detach</code></a> has been received from the remote with the close
 flag equal to true.</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="Link.html" title="type parameter in Link">L</a> extends <a href="Link.html" title="interface in org.apache.qpid.protonj2.engine">Link</a>&lt;<a href="Link.html" title="type parameter in Link">L</a>&gt;&gt;</code></dd>
<dt>Returns:</dt>
<dd>true if the link is remotely closed.</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="#isRemotelyOpen()"><code>isRemotelyOpen()</code></a></li>
<li><a href="#isRemotelyDetached()"><code>isRemotelyDetached()</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="isRemotelyDetached()">
<h3>isRemotelyDetached</h3>
<div class="member-signature"><span class="return-type">boolean</span>&nbsp;<span class="element-name">isRemotelyDetached</span>()</div>
<div class="block">Returns true if this <a href="Link.html" title="interface in org.apache.qpid.protonj2.engine"><code>Link</code></a> is currently remotely detached meaning the state returned
 from <a href="#getRemoteState()"><code>getRemoteState()</code></a> is equal to <a href="LinkState.html#DETACHED"><code>LinkState.DETACHED</code></a>.  A link
 is remotely detached after an <a href="../types/transport/Detach.html" title="class in org.apache.qpid.protonj2.types.transport"><code>Detach</code></a> has been received from the remote with the close
 flag equal to false.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>true if the link is remotely detached.</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="#isRemotelyOpen()"><code>isRemotelyOpen()</code></a></li>
<li><a href="#isRemotelyClosed()"><code>isRemotelyClosed()</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="isRemotelyClosedOrDetached()">
<h3>isRemotelyClosedOrDetached</h3>
<div class="member-signature"><span class="return-type">boolean</span>&nbsp;<span class="element-name">isRemotelyClosedOrDetached</span>()</div>
<div class="block">Returns true if this <a href="Link.html" title="interface in org.apache.qpid.protonj2.engine"><code>Link</code></a> is currently remotely detached or closed meaning the state
 returned from <a href="#getRemoteState()"><code>getRemoteState()</code></a> is equal to <a href="LinkState.html#DETACHED"><code>LinkState.DETACHED</code></a> or
 <a href="LinkState.html#CLOSED"><code>LinkState.CLOSED</code></a>.  A link is remotely detached or closed after a <a href="../types/transport/Detach.html" title="class in org.apache.qpid.protonj2.types.transport"><code>Detach</code></a>
 has been received from the remote.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>true if the link is remotely detached or closed.</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="#isRemotelyOpen()"><code>isRemotelyOpen()</code></a></li>
<li><a href="#isRemotelyClosed()"><code>isRemotelyClosed()</code></a></li>
<li><a href="#isRemotelyDetached()"><code>isRemotelyDetached()</code></a></li>
</ul>
</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/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="getRemoteTarget()">
<h3>getRemoteTarget</h3>
<div class="member-signature"><span class="type-parameters">&lt;T extends <a href="../types/messaging/Terminus.html" title="interface in org.apache.qpid.protonj2.types.messaging">Terminus</a>&gt;</span>&nbsp;<span class="return-type">T</span>&nbsp;<span class="element-name">getRemoteTarget</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> cast to the given type.  This can be used when
 the underlying type is known by the caller or as a control to validate the assumption of the
 underlying type.
 <p>
 the currently set Target for this <a href="Link.html" title="interface in org.apache.qpid.protonj2.engine"><code>Link</code></a>.  A link target can be either a <a href="../types/messaging/Target.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>Target</code></a>
 type for a <a href="Sender.html" title="interface in org.apache.qpid.protonj2.engine"><code>Sender</code></a> or <a href="Receiver.html" title="interface in org.apache.qpid.protonj2.engine"><code>Receiver</code></a> link or if the link is to be transaction resource
 then the target type will be a <a href="../types/transactions/Coordinator.html" title="class in org.apache.qpid.protonj2.types.transactions"><code>Coordinator</code></a> instance.</div>
<dl class="notes">
<dt>Type Parameters:</dt>
<dd><code>T</code> - The type that the remote <a href="../types/messaging/Terminus.html" title="interface in org.apache.qpid.protonj2.types.messaging"><code>Terminus</code></a> will be cast to on return.</dd>
<dt>Returns:</dt>
<dd>the source <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="getRemoteSenderSettleMode()">
<h3>getRemoteSenderSettleMode</h3>
<div class="member-signature"><span class="return-type"><a href="../types/transport/SenderSettleMode.html" title="enum in org.apache.qpid.protonj2.types.transport">SenderSettleMode</a></span>&nbsp;<span class="element-name">getRemoteSenderSettleMode</span>()</div>
<div class="block">Gets the remote link sender settlement mode, as conveyed from the peer via the Attach frame
 when attaching the link to the session.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the sender settlement mode conveyed by the peer, or null if there was none.</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list-long">
<li><a href="#setSenderSettleMode(org.apache.qpid.protonj2.types.transport.SenderSettleMode)"><code>setSenderSettleMode(SenderSettleMode)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getRemoteReceiverSettleMode()">
<h3>getRemoteReceiverSettleMode</h3>
<div class="member-signature"><span class="return-type"><a href="../types/transport/ReceiverSettleMode.html" title="enum in org.apache.qpid.protonj2.types.transport">ReceiverSettleMode</a></span>&nbsp;<span class="element-name">getRemoteReceiverSettleMode</span>()</div>
<div class="block">Gets the remote link receiver settlement mode, as conveyed from the peer via the Attach frame
 when attaching the link to the session.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the sender receiver mode conveyed by the peer, or null if there was none.</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list-long">
<li><a href="#setReceiverSettleMode(org.apache.qpid.protonj2.types.transport.ReceiverSettleMode)"><code>setReceiverSettleMode(ReceiverSettleMode)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getRemoteMaxMessageSize()">
<h3>getRemoteMaxMessageSize</h3>
<div class="member-signature"><span class="return-type"><a href="../types/UnsignedLong.html" title="class in org.apache.qpid.protonj2.types">UnsignedLong</a></span>&nbsp;<span class="element-name">getRemoteMaxMessageSize</span>()</div>
<div class="block">Gets the remote link max message size, as conveyed from the peer via the Attach frame
 when attaching the link to the session.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the remote max message size conveyed by the peer, or null if none was set. 0 also means no limit.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getRemoteState()">
<h3>getRemoteState</h3>
<div class="member-signature"><span class="return-type"><a href="LinkState.html" title="enum in org.apache.qpid.protonj2.engine">LinkState</a></span>&nbsp;<span class="element-name">getRemoteState</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the remote link state (as last communicated)</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="localDetachHandler(org.apache.qpid.protonj2.engine.EventHandler)">
<h3>localDetachHandler</h3>
<div class="member-signature"><span class="return-type"><a href="Link.html" title="type parameter in Link">L</a></span>&nbsp;<span class="element-name">localDetachHandler</span><wbr><span class="parameters">(<a href="EventHandler.html" title="interface in org.apache.qpid.protonj2.engine">EventHandler</a>&lt;<a href="Link.html" title="type parameter in Link">L</a>&gt;&nbsp;localDetachHandler)</span></div>
<div class="block">Sets a <a href="EventHandler.html" title="interface in org.apache.qpid.protonj2.engine"><code>EventHandler</code></a> for when an this link is detached locally via a call to <a href="#detach()"><code>detach()</code></a>

 This is a convenience event that supplements the normal <a href="Endpoint.html#localCloseHandler(org.apache.qpid.protonj2.engine.EventHandler)"><code>Endpoint.localCloseHandler(EventHandler)</code></a>
 event point if set.  If no local detached event handler is set the endpoint will route the detached event
 to the local closed event handler if set and allow it to process the event in one location.
 <p>
 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>localDetachHandler</code> - The <a href="EventHandler.html" title="interface in org.apache.qpid.protonj2.engine"><code>EventHandler</code></a> to notify when this link is locally detached.</dd>
<dt>Returns:</dt>
<dd>the link for chaining.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="detachHandler(org.apache.qpid.protonj2.engine.EventHandler)">
<h3>detachHandler</h3>
<div class="member-signature"><span class="return-type"><a href="Link.html" title="type parameter in Link">L</a></span>&nbsp;<span class="element-name">detachHandler</span><wbr><span class="parameters">(<a href="EventHandler.html" title="interface in org.apache.qpid.protonj2.engine">EventHandler</a>&lt;<a href="Link.html" title="type parameter in Link">L</a>&gt;&nbsp;remoteDetachHandler)</span></div>
<div class="block">Sets a <a href="EventHandler.html" title="interface in org.apache.qpid.protonj2.engine"><code>EventHandler</code></a> for when an AMQP Detach frame is received from the remote peer for this
 <a href="Link.html" title="interface in org.apache.qpid.protonj2.engine"><code>Link</code></a> which would have been locally opened previously, the Detach from would have been marked
 as not having been closed.
 <p>
 This is a convenience event that supplements the normal <a href="Endpoint.html#closeHandler(org.apache.qpid.protonj2.engine.EventHandler)"><code>Endpoint.closeHandler(EventHandler)</code></a>
 event point if set.  If no detached event handler is set the endpoint will route the detached event to the
 closed event handler if set and allow it to process the event in one location.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>remoteDetachHandler</code> - The <a href="EventHandler.html" title="interface in org.apache.qpid.protonj2.engine"><code>EventHandler</code></a> to notify when this link is remotely closed.</dd>
<dt>Returns:</dt>
<dd>the <a href="Link.html" title="interface in org.apache.qpid.protonj2.engine"><code>Link</code></a> for chaining.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="creditStateUpdateHandler(org.apache.qpid.protonj2.engine.EventHandler)">
<h3>creditStateUpdateHandler</h3>
<div class="member-signature"><span class="return-type"><a href="Link.html" title="type parameter in Link">L</a></span>&nbsp;<span class="element-name">creditStateUpdateHandler</span><wbr><span class="parameters">(<a href="EventHandler.html" title="interface in org.apache.qpid.protonj2.engine">EventHandler</a>&lt;<a href="Link.html" title="type parameter in Link">L</a>&gt;&nbsp;handler)</span></div>
<div class="block">Handler for link credit updates that occur after a remote <a href="../types/transport/Flow.html" title="class in org.apache.qpid.protonj2.types.transport"><code>Flow</code></a> arrives.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>handler</code> - An event handler that will be signaled when the link credit is updated by a remote flow.</dd>
<dt>Returns:</dt>
<dd>the <a href="Link.html" title="interface in org.apache.qpid.protonj2.engine"><code>Link</code></a> for chaining.</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="Link.html" title="type parameter in Link">L</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="Link.html" title="type parameter in Link">L</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 link is
 locally closed.
 <p>
 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 link's parent Session 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>
