<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>ClientLinkType (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.client.impl, class: ClientLinkType">
<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/ClientLinkType.html">Use</a></li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../../../help-doc.html#class">Help</a></li>
</ul>
</div>
<div class="sub-nav">
<div>
<ul class="sub-nav-list">
<li>Summary:&nbsp;</li>
<li>Nested&nbsp;|&nbsp;</li>
<li><a href="#field-summary">Field</a>&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method-summary">Method</a></li>
</ul>
<ul class="sub-nav-list">
<li>Detail:&nbsp;</li>
<li><a href="#field-detail">Field</a>&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.client.impl</a></div>
<h1 title="Class ClientLinkType" class="title">Class ClientLinkType&lt;LinkType extends <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client">Link</a>&lt;LinkType&gt;,<wbr>ProtonType extends <a href="../../engine/Link.html" title="interface in org.apache.qpid.protonj2.engine">Link</a>&lt;ProtonType&gt;&gt;</h1>
</div>
<div class="inheritance" title="Inheritance Tree"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">java.lang.Object</a>
<div class="inheritance">org.apache.qpid.protonj2.client.impl.ClientLinkType&lt;LinkType,<wbr>ProtonType&gt;</div>
</div>
<section class="class-description" id="class-description">
<dl class="notes">
<dt>Type Parameters:</dt>
<dd><code>LinkType</code> - The actual link type implementation ClientSender or ClientReceiver</dd>
<dd><code>ProtonType</code> - The proton concrete link type implementation Sender or Receiver</dd>
</dl>
<dl class="notes">
<dt>All Implemented Interfaces:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/AutoCloseable.html" title="class or interface in java.lang" class="external-link">AutoCloseable</a></code>, <code><a href="../Link.html" title="interface in org.apache.qpid.protonj2.client">Link</a>&lt;LinkType&gt;</code></dd>
</dl>
<dl class="notes">
<dt>Direct Known Subclasses:</dt>
<dd><code><a href="ClientReceiverLinkType.html" title="class in org.apache.qpid.protonj2.client.impl">ClientReceiverLinkType</a></code>, <code><a href="ClientSenderLinkType.html" title="class in org.apache.qpid.protonj2.client.impl">ClientSenderLinkType</a></code></dd>
</dl>
<hr>
<div class="type-signature"><span class="modifiers">public abstract class </span><span class="element-name type-name-label">ClientLinkType&lt;LinkType extends <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client">Link</a>&lt;LinkType&gt;,<wbr>ProtonType extends <a href="../../engine/Link.html" title="interface in org.apache.qpid.protonj2.engine">Link</a>&lt;ProtonType&gt;&gt;</span>
<span class="extends-implements">extends <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>
implements <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client">Link</a>&lt;LinkType&gt;</span></div>
<div class="block">Base type used by client resources that represent an AMQP link type.</div>
</section>
<section class="summary">
<ul class="summary-list">
<!-- =========== FIELD SUMMARY =========== -->
<li>
<section class="field-summary" id="field-summary">
<h2>Field Summary</h2>
<div class="caption"><span>Fields</span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Field</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code>protected int</code></div>
<div class="col-second even-row-color"><code><a href="#closed" class="member-name-link">closed</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>protected static final <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/atomic/AtomicIntegerFieldUpdater.html" title="class or interface in java.util.concurrent.atomic" class="external-link">AtomicIntegerFieldUpdater</a>&lt;<a href="ClientLinkType.html" title="class in org.apache.qpid.protonj2.client.impl">ClientLinkType</a>&gt;</code></div>
<div class="col-second odd-row-color"><code><a href="#CLOSED_UPDATER" class="member-name-link">CLOSED_UPDATER</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>protected final <a href="../futures/ClientFuture.html" title="class in org.apache.qpid.protonj2.client.futures">ClientFuture</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a>&gt;</code></div>
<div class="col-second even-row-color"><code><a href="#closeFuture" class="member-name-link">closeFuture</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>protected final <a href="../../engine/Scheduler.html" title="interface in org.apache.qpid.protonj2.engine">Scheduler</a></code></div>
<div class="col-second odd-row-color"><code><a href="#executor" class="member-name-link">executor</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>protected <a href="../exceptions/ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a></code></div>
<div class="col-second even-row-color"><code><a href="#failureCause" class="member-name-link">failureCause</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>protected final <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 odd-row-color"><code><a href="#linkId" class="member-name-link">linkId</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>protected <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/function/Consumer.html" title="class or interface in java.util.function" class="external-link">Consumer</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a>&gt;</code></div>
<div class="col-second even-row-color"><code><a href="#linkRemotelyClosedHandler" class="member-name-link">linkRemotelyClosedHandler</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>protected final <a href="../futures/ClientFuture.html" title="class in org.apache.qpid.protonj2.client.futures">ClientFuture</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a>&gt;</code></div>
<div class="col-second odd-row-color"><code><a href="#openFuture" class="member-name-link">openFuture</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>protected final <a href="../LinkOptions.html" title="class in org.apache.qpid.protonj2.client">LinkOptions</a>&lt;?&gt;</code></div>
<div class="col-second even-row-color"><code><a href="#options" class="member-name-link">options</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>protected <a href="../Source.html" title="interface in org.apache.qpid.protonj2.client">Source</a></code></div>
<div class="col-second odd-row-color"><code><a href="#remoteSource" class="member-name-link">remoteSource</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>protected <a href="../Target.html" title="interface in org.apache.qpid.protonj2.client">Target</a></code></div>
<div class="col-second even-row-color"><code><a href="#remoteTarget" class="member-name-link">remoteTarget</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>protected final <a href="ClientSession.html" title="class in org.apache.qpid.protonj2.client.impl">ClientSession</a></code></div>
<div class="col-second odd-row-color"><code><a href="#session" class="member-name-link">session</a></code></div>
<div class="col-last odd-row-color">&nbsp;</div>
</div>
</section>
</li>
<!-- ========== METHOD SUMMARY =========== -->
<li>
<section class="method-summary" id="method-summary">
<h2>Method Summary</h2>
<div id="method-summary-table">
<div class="table-tabs" role="tablist" aria-orientation="horizontal"><button id="method-summary-table-tab0" role="tab" aria-selected="true" aria-controls="method-summary-table.tabpanel" tabindex="0" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table', 3)" class="active-table-tab">All Methods</button><button id="method-summary-table-tab2" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab2', 3)" class="table-tab">Instance Methods</button><button id="method-summary-table-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><button id="method-summary-table-tab4" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab4', 3)" class="table-tab">Concrete Methods</button></div>
<div id="method-summary-table.tabpanel" role="tabpanel">
<div class="summary-table three-column-summary" aria-labelledby="method-summary-table-tab0">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Method</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#address()" class="member-name-link">address</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns the address that the <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client"><code>Link</code></a> instance will be subscribed to.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#checkClosedOrFailed()" class="member-name-link">checkClosedOrFailed</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ClientInstance.html" title="class in org.apache.qpid.protonj2.client.impl">ClientInstance</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#client()" class="member-name-link">client</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#close()" class="member-name-link">close</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Requests a close of the <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client"><code>Link</code></a> at the remote and waits until the Link has been
 fully closed or until the configured close timeout is exceeded.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#close(org.apache.qpid.protonj2.client.ErrorCondition)" class="member-name-link">close</a><wbr>(<a href="../ErrorCondition.html" title="interface in org.apache.qpid.protonj2.client">ErrorCondition</a>&nbsp;error)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Requests a close of the <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client"><code>Link</code></a> at the remote and waits until the Link has been
 fully closed or until the configured <a href="../LinkOptions.html#closeTimeout()"><code>LinkOptions.closeTimeout()</code></a> is exceeded.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../futures/ClientFuture.html" title="class in org.apache.qpid.protonj2.client.futures">ClientFuture</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#closeAsync()" class="member-name-link">closeAsync</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Requests a close of the <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client"><code>Link</code></a> link at the remote and returns a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/Future.html" title="class or interface in java.util.concurrent" class="external-link"><code>Future</code></a> that will be
 completed once the link has been closed.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../futures/ClientFuture.html" title="class in org.apache.qpid.protonj2.client.futures">ClientFuture</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#closeAsync(org.apache.qpid.protonj2.client.ErrorCondition)" class="member-name-link">closeAsync</a><wbr>(<a href="../ErrorCondition.html" title="interface in org.apache.qpid.protonj2.client">ErrorCondition</a>&nbsp;error)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Requests a close of the <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client"><code>Link</code></a> link at the remote and returns a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/Future.html" title="class or interface in java.util.concurrent" class="external-link"><code>Future</code></a> that will be
 completed once the link has been closed.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ClientConnection.html" title="class in org.apache.qpid.protonj2.client.impl">ClientConnection</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#connection()" class="member-name-link">connection</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>[]</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#desiredCapabilities()" class="member-name-link">desiredCapabilities</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns the desired capabilities that the remote provided upon successfully opening the <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client"><code>Link</code></a>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#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-tab4">
<div class="block">Requests a detach of the <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client"><code>Link</code></a> at the remote and waits until the Link has been
 fully detached or until the configured <a href="../LinkOptions.html#closeTimeout()"><code>LinkOptions.closeTimeout()</code></a> is exceeded.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#detach(org.apache.qpid.protonj2.client.ErrorCondition)" class="member-name-link">detach</a><wbr>(<a href="../ErrorCondition.html" title="interface in org.apache.qpid.protonj2.client">ErrorCondition</a>&nbsp;error)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Requests a detach of the <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client"><code>Link</code></a> at the remote and waits until the Link has been
 fully detached or until the configured <a href="../LinkOptions.html#closeTimeout()"><code>LinkOptions.closeTimeout()</code></a> is exceeded.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../futures/ClientFuture.html" title="class in org.apache.qpid.protonj2.client.futures">ClientFuture</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#detachAsync()" class="member-name-link">detachAsync</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Requests a detach of the <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client"><code>Link</code></a> link at the remote and returns a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/Future.html" title="class or interface in java.util.concurrent" class="external-link"><code>Future</code></a> that will be
 completed once the link has been detached.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../futures/ClientFuture.html" title="class in org.apache.qpid.protonj2.client.futures">ClientFuture</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#detachAsync(org.apache.qpid.protonj2.client.ErrorCondition)" class="member-name-link">detachAsync</a><wbr>(<a href="../ErrorCondition.html" title="interface in org.apache.qpid.protonj2.client">ErrorCondition</a>&nbsp;error)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Requests a detach of the <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client"><code>Link</code></a> link at the remote and returns a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/Future.html" title="class or interface in java.util.concurrent" class="external-link"><code>Future</code></a> that will be
 completed once the link has been detached.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected final void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#handleEngineShutdown(org.apache.qpid.protonj2.engine.Engine)" class="member-name-link">handleEngineShutdown</a><wbr>(<a href="../../engine/Engine.html" title="interface in org.apache.qpid.protonj2.engine">Engine</a>&nbsp;engine)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected final void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#handleLocalCloseOrDetach(ProtonType)" class="member-name-link">handleLocalCloseOrDetach</a><wbr>(<a href="ClientLinkType.html" title="type parameter in ClientLinkType">ProtonType</a>&nbsp;link)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected final void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#handleLocalOpen(ProtonType)" class="member-name-link">handleLocalOpen</a><wbr>(<a href="ClientLinkType.html" title="type parameter in ClientLinkType">ProtonType</a>&nbsp;link)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected final void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#handleParentEndpointClosed(ProtonType)" class="member-name-link">handleParentEndpointClosed</a><wbr>(<a href="ClientLinkType.html" title="type parameter in ClientLinkType">ProtonType</a>&nbsp;link)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected final void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#handleRemoteCloseOrDetach(ProtonType)" class="member-name-link">handleRemoteCloseOrDetach</a><wbr>(<a href="ClientLinkType.html" title="type parameter in ClientLinkType">ProtonType</a>&nbsp;link)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected final void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#handleRemoteOpen(ProtonType)" class="member-name-link">handleRemoteOpen</a><wbr>(<a href="ClientLinkType.html" title="type parameter in ClientLinkType">ProtonType</a>&nbsp;link)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected final void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#immediateLinkShutdown(org.apache.qpid.protonj2.client.exceptions.ClientException)" class="member-name-link">immediateLinkShutdown</a><wbr>(<a href="../exceptions/ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a>&nbsp;failureCause)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>protected abstract void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#linkSpecificCleanupHandler(org.apache.qpid.protonj2.client.exceptions.ClientException)" class="member-name-link">linkSpecificCleanupHandler</a><wbr>(<a href="../exceptions/ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a>&nbsp;failureCause)</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>protected abstract void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#linkSpecificLocalCloseHandler()" class="member-name-link">linkSpecificLocalCloseHandler</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>protected abstract void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#linkSpecificLocalOpenHandler()" class="member-name-link">linkSpecificLocalOpenHandler</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>protected abstract void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#linkSpecificRemoteCloseHandler()" class="member-name-link">linkSpecificRemoteCloseHandler</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>protected abstract void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#linkSpecificRemoteOpenHandler()" class="member-name-link">linkSpecificRemoteOpenHandler</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-tab4"><code>protected boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#notClosedOrFailed(org.apache.qpid.protonj2.client.futures.ClientFuture)" class="member-name-link">notClosedOrFailed</a><wbr>(<a href="../futures/ClientFuture.html" title="class in org.apache.qpid.protonj2.client.futures">ClientFuture</a>&lt;?&gt;&nbsp;request)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#notClosedOrFailed(org.apache.qpid.protonj2.client.futures.ClientFuture,ProtonType)" class="member-name-link">notClosedOrFailed</a><wbr>(<a href="../futures/ClientFuture.html" title="class in org.apache.qpid.protonj2.client.futures">ClientFuture</a>&lt;?&gt;&nbsp;request,
 <a href="ClientLinkType.html" title="type parameter in ClientLinkType">ProtonType</a>&nbsp;protonLink)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>[]</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#offeredCapabilities()" class="member-name-link">offeredCapabilities</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns the offered capabilities that the remote provided upon successfully opening the <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client"><code>Link</code></a>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../futures/ClientFuture.html" title="class in org.apache.qpid.protonj2.client.futures">ClientFuture</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#openFuture()" class="member-name-link">openFuture</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="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>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#properties()" class="member-name-link">properties</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns the properties that the remote provided upon successfully opening the <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client"><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>protected abstract <a href="ClientLinkType.html" title="type parameter in ClientLinkType">ProtonType</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#protonLink()" class="member-name-link">protonLink</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>protected abstract void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#recreateLinkForReconnect()" class="member-name-link">recreateLinkForReconnect</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>protected abstract <a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#self()" class="member-name-link">self</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-tab4"><code><a href="ClientSession.html" title="class in org.apache.qpid.protonj2.client.impl">ClientSession</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#session()" class="member-name-link">session</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../Source.html" title="interface in org.apache.qpid.protonj2.client">Source</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#source()" class="member-name-link">source</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns an immutable view of the remote <a href="../Source.html" title="interface in org.apache.qpid.protonj2.client"><code>Source</code></a> object assigned to this link.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../Target.html" title="interface in org.apache.qpid.protonj2.client">Target</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#target()" class="member-name-link">target</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns an immutable view of the remote <a href="../Target.html" title="interface in org.apache.qpid.protonj2.client"><code>Target</code></a> object assigned to this sender link.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#waitForOpenToComplete()" class="member-name-link">waitForOpenToComplete</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
</div>
</div>
</div>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-java.lang.Object">Methods inherited from class&nbsp;java.lang.<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></h3>
<code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#clone()" title="class or interface in java.lang" class="external-link">clone</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#equals(java.lang.Object)" title="class or interface in java.lang" class="external-link">equals</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#finalize()" title="class or interface in java.lang" class="external-link">finalize</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#getClass()" title="class or interface in java.lang" class="external-link">getClass</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#hashCode()" title="class or interface in java.lang" class="external-link">hashCode</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#notify()" title="class or interface in java.lang" class="external-link">notify</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#notifyAll()" title="class or interface in java.lang" class="external-link">notifyAll</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#toString()" title="class or interface in java.lang" class="external-link">toString</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#wait()" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#wait(long)" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#wait(long,int)" title="class or interface in java.lang" class="external-link">wait</a></code></div>
</section>
</li>
</ul>
</section>
<section class="details">
<ul class="details-list">
<!-- ============ FIELD DETAIL =========== -->
<li>
<section class="field-details" id="field-detail">
<h2>Field Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="CLOSED_UPDATER">
<h3>CLOSED_UPDATER</h3>
<div class="member-signature"><span class="modifiers">protected static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/atomic/AtomicIntegerFieldUpdater.html" title="class or interface in java.util.concurrent.atomic" class="external-link">AtomicIntegerFieldUpdater</a>&lt;<a href="ClientLinkType.html" title="class in org.apache.qpid.protonj2.client.impl">ClientLinkType</a>&gt;</span>&nbsp;<span class="element-name">CLOSED_UPDATER</span></div>
</section>
</li>
<li>
<section class="detail" id="openFuture">
<h3>openFuture</h3>
<div class="member-signature"><span class="modifiers">protected final</span>&nbsp;<span class="return-type"><a href="../futures/ClientFuture.html" title="class in org.apache.qpid.protonj2.client.futures">ClientFuture</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a> extends <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client">Link</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a>&gt;&gt;</span>&nbsp;<span class="element-name">openFuture</span></div>
</section>
</li>
<li>
<section class="detail" id="closeFuture">
<h3>closeFuture</h3>
<div class="member-signature"><span class="modifiers">protected final</span>&nbsp;<span class="return-type"><a href="../futures/ClientFuture.html" title="class in org.apache.qpid.protonj2.client.futures">ClientFuture</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a> extends <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client">Link</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a>&gt;&gt;</span>&nbsp;<span class="element-name">closeFuture</span></div>
</section>
</li>
<li>
<section class="detail" id="closed">
<h3>closed</h3>
<div class="member-signature"><span class="modifiers">protected volatile</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">closed</span></div>
</section>
</li>
<li>
<section class="detail" id="failureCause">
<h3>failureCause</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type"><a href="../exceptions/ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a></span>&nbsp;<span class="element-name">failureCause</span></div>
</section>
</li>
<li>
<section class="detail" id="session">
<h3>session</h3>
<div class="member-signature"><span class="modifiers">protected final</span>&nbsp;<span class="return-type"><a href="ClientSession.html" title="class in org.apache.qpid.protonj2.client.impl">ClientSession</a></span>&nbsp;<span class="element-name">session</span></div>
</section>
</li>
<li>
<section class="detail" id="executor">
<h3>executor</h3>
<div class="member-signature"><span class="modifiers">protected final</span>&nbsp;<span class="return-type"><a href="../../engine/Scheduler.html" title="interface in org.apache.qpid.protonj2.engine">Scheduler</a></span>&nbsp;<span class="element-name">executor</span></div>
</section>
</li>
<li>
<section class="detail" id="linkId">
<h3>linkId</h3>
<div class="member-signature"><span class="modifiers">protected final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">linkId</span></div>
</section>
</li>
<li>
<section class="detail" id="options">
<h3>options</h3>
<div class="member-signature"><span class="modifiers">protected final</span>&nbsp;<span class="return-type"><a href="../LinkOptions.html" title="class in org.apache.qpid.protonj2.client">LinkOptions</a>&lt;?&gt;</span>&nbsp;<span class="element-name">options</span></div>
</section>
</li>
<li>
<section class="detail" id="remoteSource">
<h3>remoteSource</h3>
<div class="member-signature"><span class="modifiers">protected volatile</span>&nbsp;<span class="return-type"><a href="../Source.html" title="interface in org.apache.qpid.protonj2.client">Source</a></span>&nbsp;<span class="element-name">remoteSource</span></div>
</section>
</li>
<li>
<section class="detail" id="remoteTarget">
<h3>remoteTarget</h3>
<div class="member-signature"><span class="modifiers">protected volatile</span>&nbsp;<span class="return-type"><a href="../Target.html" title="interface in org.apache.qpid.protonj2.client">Target</a></span>&nbsp;<span class="element-name">remoteTarget</span></div>
</section>
</li>
<li>
<section class="detail" id="linkRemotelyClosedHandler">
<h3>linkRemotelyClosedHandler</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/function/Consumer.html" title="class or interface in java.util.function" class="external-link">Consumer</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a> extends <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client">Link</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a>&gt;&gt;</span>&nbsp;<span class="element-name">linkRemotelyClosedHandler</span></div>
</section>
</li>
</ul>
</section>
</li>
<!-- ============ METHOD DETAIL ========== -->
<li>
<section class="method-details" id="method-detail">
<h2>Method Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="self()">
<h3>self</h3>
<div class="member-signature"><span class="modifiers">protected abstract</span>&nbsp;<span class="return-type"><a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a></span>&nbsp;<span class="element-name">self</span>()</div>
</section>
</li>
<li>
<section class="detail" id="protonLink()">
<h3>protonLink</h3>
<div class="member-signature"><span class="modifiers">protected abstract</span>&nbsp;<span class="return-type"><a href="ClientLinkType.html" title="type parameter in ClientLinkType">ProtonType</a></span>&nbsp;<span class="element-name">protonLink</span>()</div>
</section>
</li>
<li>
<section class="detail" id="close()">
<h3>close</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">close</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Link.html#close()">Link</a></code></span></div>
<div class="block">Requests a close of the <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client"><code>Link</code></a> at the remote and waits until the Link has been
 fully closed or until the configured close timeout is exceeded.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/AutoCloseable.html#close()" title="class or interface in java.lang" class="external-link">close</a></code>&nbsp;in interface&nbsp;<code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/AutoCloseable.html" title="class or interface in java.lang" class="external-link">AutoCloseable</a></code></dd>
<dt>Specified by:</dt>
<dd><code><a href="../Link.html#close()">close</a></code>&nbsp;in interface&nbsp;<code><a href="../Link.html" title="interface in org.apache.qpid.protonj2.client">Link</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a> extends <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client">Link</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a>&gt;&gt;</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="close(org.apache.qpid.protonj2.client.ErrorCondition)">
<h3>close</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">close</span><wbr><span class="parameters">(<a href="../ErrorCondition.html" title="interface in org.apache.qpid.protonj2.client">ErrorCondition</a>&nbsp;error)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Link.html#close(org.apache.qpid.protonj2.client.ErrorCondition)">Link</a></code></span></div>
<div class="block">Requests a close of the <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client"><code>Link</code></a> at the remote and waits until the Link has been
 fully closed or until the configured <a href="../LinkOptions.html#closeTimeout()"><code>LinkOptions.closeTimeout()</code></a> is exceeded.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Link.html#close(org.apache.qpid.protonj2.client.ErrorCondition)">close</a></code>&nbsp;in interface&nbsp;<code><a href="../Link.html" title="interface in org.apache.qpid.protonj2.client">Link</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a> extends <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client">Link</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a>&gt;&gt;</code></dd>
<dt>Parameters:</dt>
<dd><code>error</code> - The <a href="../ErrorCondition.html" title="interface in org.apache.qpid.protonj2.client"><code>ErrorCondition</code></a> to transmit to the remote along with the close operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="detach()">
<h3>detach</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">detach</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Link.html#detach()">Link</a></code></span></div>
<div class="block">Requests a detach of the <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client"><code>Link</code></a> at the remote and waits until the Link has been
 fully detached or until the configured <a href="../LinkOptions.html#closeTimeout()"><code>LinkOptions.closeTimeout()</code></a> is exceeded.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Link.html#detach()">detach</a></code>&nbsp;in interface&nbsp;<code><a href="../Link.html" title="interface in org.apache.qpid.protonj2.client">Link</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a> extends <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client">Link</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a>&gt;&gt;</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="detach(org.apache.qpid.protonj2.client.ErrorCondition)">
<h3>detach</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">detach</span><wbr><span class="parameters">(<a href="../ErrorCondition.html" title="interface in org.apache.qpid.protonj2.client">ErrorCondition</a>&nbsp;error)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Link.html#detach(org.apache.qpid.protonj2.client.ErrorCondition)">Link</a></code></span></div>
<div class="block">Requests a detach of the <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client"><code>Link</code></a> at the remote and waits until the Link has been
 fully detached or until the configured <a href="../LinkOptions.html#closeTimeout()"><code>LinkOptions.closeTimeout()</code></a> is exceeded.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Link.html#detach(org.apache.qpid.protonj2.client.ErrorCondition)">detach</a></code>&nbsp;in interface&nbsp;<code><a href="../Link.html" title="interface in org.apache.qpid.protonj2.client">Link</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a> extends <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client">Link</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a>&gt;&gt;</code></dd>
<dt>Parameters:</dt>
<dd><code>error</code> - The <a href="../ErrorCondition.html" title="interface in org.apache.qpid.protonj2.client"><code>ErrorCondition</code></a> to transmit to the remote along with the detach operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="closeAsync()">
<h3>closeAsync</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../futures/ClientFuture.html" title="class in org.apache.qpid.protonj2.client.futures">ClientFuture</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a>&gt;</span>&nbsp;<span class="element-name">closeAsync</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Link.html#closeAsync()">Link</a></code></span></div>
<div class="block">Requests a close of the <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client"><code>Link</code></a> link at the remote and returns a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/Future.html" title="class or interface in java.util.concurrent" class="external-link"><code>Future</code></a> that will be
 completed once the link has been closed.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Link.html#closeAsync()">closeAsync</a></code>&nbsp;in interface&nbsp;<code><a href="../Link.html" title="interface in org.apache.qpid.protonj2.client">Link</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a> extends <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client">Link</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a>&gt;&gt;</code></dd>
<dt>Returns:</dt>
<dd>a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/Future.html" title="class or interface in java.util.concurrent" class="external-link"><code>Future</code></a> that will be completed when the remote closes this <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client"><code>Link</code></a> link.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="closeAsync(org.apache.qpid.protonj2.client.ErrorCondition)">
<h3>closeAsync</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../futures/ClientFuture.html" title="class in org.apache.qpid.protonj2.client.futures">ClientFuture</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a>&gt;</span>&nbsp;<span class="element-name">closeAsync</span><wbr><span class="parameters">(<a href="../ErrorCondition.html" title="interface in org.apache.qpid.protonj2.client">ErrorCondition</a>&nbsp;error)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Link.html#closeAsync(org.apache.qpid.protonj2.client.ErrorCondition)">Link</a></code></span></div>
<div class="block">Requests a close of the <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client"><code>Link</code></a> link at the remote and returns a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/Future.html" title="class or interface in java.util.concurrent" class="external-link"><code>Future</code></a> that will be
 completed once the link has been closed.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Link.html#closeAsync(org.apache.qpid.protonj2.client.ErrorCondition)">closeAsync</a></code>&nbsp;in interface&nbsp;<code><a href="../Link.html" title="interface in org.apache.qpid.protonj2.client">Link</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a> extends <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client">Link</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a>&gt;&gt;</code></dd>
<dt>Parameters:</dt>
<dd><code>error</code> - The <a href="../ErrorCondition.html" title="interface in org.apache.qpid.protonj2.client"><code>ErrorCondition</code></a> to transmit to the remote along with the close operation.</dd>
<dt>Returns:</dt>
<dd>a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/Future.html" title="class or interface in java.util.concurrent" class="external-link"><code>Future</code></a> that will be completed when the remote closes this <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client"><code>Link</code></a> link.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="detachAsync()">
<h3>detachAsync</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../futures/ClientFuture.html" title="class in org.apache.qpid.protonj2.client.futures">ClientFuture</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a>&gt;</span>&nbsp;<span class="element-name">detachAsync</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Link.html#detachAsync()">Link</a></code></span></div>
<div class="block">Requests a detach of the <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client"><code>Link</code></a> link at the remote and returns a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/Future.html" title="class or interface in java.util.concurrent" class="external-link"><code>Future</code></a> that will be
 completed once the link has been detached.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Link.html#detachAsync()">detachAsync</a></code>&nbsp;in interface&nbsp;<code><a href="../Link.html" title="interface in org.apache.qpid.protonj2.client">Link</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a> extends <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client">Link</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a>&gt;&gt;</code></dd>
<dt>Returns:</dt>
<dd>a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/Future.html" title="class or interface in java.util.concurrent" class="external-link"><code>Future</code></a> that will be completed when the remote detaches this <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client"><code>Link</code></a> link.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="detachAsync(org.apache.qpid.protonj2.client.ErrorCondition)">
<h3>detachAsync</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../futures/ClientFuture.html" title="class in org.apache.qpid.protonj2.client.futures">ClientFuture</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a>&gt;</span>&nbsp;<span class="element-name">detachAsync</span><wbr><span class="parameters">(<a href="../ErrorCondition.html" title="interface in org.apache.qpid.protonj2.client">ErrorCondition</a>&nbsp;error)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Link.html#detachAsync(org.apache.qpid.protonj2.client.ErrorCondition)">Link</a></code></span></div>
<div class="block">Requests a detach of the <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client"><code>Link</code></a> link at the remote and returns a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/Future.html" title="class or interface in java.util.concurrent" class="external-link"><code>Future</code></a> that will be
 completed once the link has been detached.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Link.html#detachAsync(org.apache.qpid.protonj2.client.ErrorCondition)">detachAsync</a></code>&nbsp;in interface&nbsp;<code><a href="../Link.html" title="interface in org.apache.qpid.protonj2.client">Link</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a> extends <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client">Link</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a>&gt;&gt;</code></dd>
<dt>Parameters:</dt>
<dd><code>error</code> - The <a href="../ErrorCondition.html" title="interface in org.apache.qpid.protonj2.client"><code>ErrorCondition</code></a> to transmit to the remote along with the detach operation.</dd>
<dt>Returns:</dt>
<dd>a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/Future.html" title="class or interface in java.util.concurrent" class="external-link"><code>Future</code></a> that will be completed when the remote detaches this <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client"><code>Link</code></a> link.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="address()">
<h3>address</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">address</span>()
               throws <span class="exceptions"><a href="../exceptions/ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Link.html#address()">Link</a></code></span></div>
<div class="block">Returns the address that the <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client"><code>Link</code></a> instance will be subscribed to. This method can
 block based on the type of link and how it was configured.

 <ul>
  <li>
    If the link is a Sender and it was configured as an anonymous sender then this method
    returns null as the link has no address.
  </li>
  <li>
   If a link was created with the dynamic node value enabled then the method will return
   the dynamically created address once the remote has attached its end of the opened link.
   Due to the need to await the remote peer to populate the dynamic address this method will
   block until the open of the link has completed.
  </li>
  <li>
   If not a dynamic link then the address returned is the address passed to the original
   link creation method.
  </li>
 </ul></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Link.html#address()">address</a></code>&nbsp;in interface&nbsp;<code><a href="../Link.html" title="interface in org.apache.qpid.protonj2.client">Link</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a> extends <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client">Link</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a>&gt;&gt;</code></dd>
<dt>Returns:</dt>
<dd>the address that this <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client"><code>Link</code></a> is was assigned to.</dd>
<dt>Throws:</dt>
<dd><code><a href="../exceptions/ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a></code> - if an error occurs while obtaining the <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client"><code>Link</code></a> address.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="source()">
<h3>source</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../Source.html" title="interface in org.apache.qpid.protonj2.client">Source</a></span>&nbsp;<span class="element-name">source</span>()
              throws <span class="exceptions"><a href="../exceptions/ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Link.html#source()">Link</a></code></span></div>
<div class="block">Returns an immutable view of the remote <a href="../Source.html" title="interface in org.apache.qpid.protonj2.client"><code>Source</code></a> object assigned to this link.  If the attach
 has not completed yet this method will block to await the attach response which carries the remote
 <a href="../Source.html" title="interface in org.apache.qpid.protonj2.client"><code>Source</code></a>.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Link.html#source()">source</a></code>&nbsp;in interface&nbsp;<code><a href="../Link.html" title="interface in org.apache.qpid.protonj2.client">Link</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a> extends <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client">Link</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a>&gt;&gt;</code></dd>
<dt>Returns:</dt>
<dd>the remote <a href="../Source.html" title="interface in org.apache.qpid.protonj2.client"><code>Source</code></a> node configuration.</dd>
<dt>Throws:</dt>
<dd><code><a href="../exceptions/ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a></code> - if an error occurs while obtaining the <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client"><code>Link</code></a> remote <a href="../Source.html" title="interface in org.apache.qpid.protonj2.client"><code>Source</code></a>.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="target()">
<h3>target</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../Target.html" title="interface in org.apache.qpid.protonj2.client">Target</a></span>&nbsp;<span class="element-name">target</span>()
              throws <span class="exceptions"><a href="../exceptions/ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Link.html#target()">Link</a></code></span></div>
<div class="block">Returns an immutable view of the remote <a href="../Target.html" title="interface in org.apache.qpid.protonj2.client"><code>Target</code></a> object assigned to this sender link.  If the
 attach has not completed yet this method will block to await the attach response which carries the remote
 <a href="../Target.html" title="interface in org.apache.qpid.protonj2.client"><code>Target</code></a>.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Link.html#target()">target</a></code>&nbsp;in interface&nbsp;<code><a href="../Link.html" title="interface in org.apache.qpid.protonj2.client">Link</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a> extends <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client">Link</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a>&gt;&gt;</code></dd>
<dt>Returns:</dt>
<dd>the remote <a href="../Target.html" title="interface in org.apache.qpid.protonj2.client"><code>Target</code></a> node configuration.</dd>
<dt>Throws:</dt>
<dd><code><a href="../exceptions/ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a></code> - if an error occurs while obtaining the <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client"><code>Link</code></a> remote <a href="../Target.html" title="interface in org.apache.qpid.protonj2.client"><code>Target</code></a>.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="properties()">
<h3>properties</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="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>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;</span>&nbsp;<span class="element-name">properties</span>()
                              throws <span class="exceptions"><a href="../exceptions/ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Link.html#properties()">Link</a></code></span></div>
<div class="block">Returns the properties that the remote provided upon successfully opening the <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client"><code>Link</code></a>.  If the
 attach has not completed yet this method will block to await the attach response which carries the remote
 properties.  If the remote provides no properties this method will return null.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Link.html#properties()">properties</a></code>&nbsp;in interface&nbsp;<code><a href="../Link.html" title="interface in org.apache.qpid.protonj2.client">Link</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a> extends <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client">Link</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a>&gt;&gt;</code></dd>
<dt>Returns:</dt>
<dd>any properties provided from the remote once the sender has successfully opened.</dd>
<dt>Throws:</dt>
<dd><code><a href="../exceptions/ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a></code> - if an error occurs while obtaining the <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client"><code>Link</code></a> remote properties.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="offeredCapabilities()">
<h3>offeredCapabilities</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>[]</span>&nbsp;<span class="element-name">offeredCapabilities</span>()
                             throws <span class="exceptions"><a href="../exceptions/ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Link.html#offeredCapabilities()">Link</a></code></span></div>
<div class="block">Returns the offered capabilities that the remote provided upon successfully opening the <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client"><code>Link</code></a>.
 If the attach has not completed yet this method will block to await the attach response which carries the
 remote offered capabilities.  If the remote provides no capabilities this method will return null.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Link.html#offeredCapabilities()">offeredCapabilities</a></code>&nbsp;in interface&nbsp;<code><a href="../Link.html" title="interface in org.apache.qpid.protonj2.client">Link</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a> extends <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client">Link</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a>&gt;&gt;</code></dd>
<dt>Returns:</dt>
<dd>any capabilities provided from the remote once the sender has successfully opened.</dd>
<dt>Throws:</dt>
<dd><code><a href="../exceptions/ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a></code> - if an error occurs while obtaining the <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client"><code>Link</code></a> remote offered capabilities.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="desiredCapabilities()">
<h3>desiredCapabilities</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>[]</span>&nbsp;<span class="element-name">desiredCapabilities</span>()
                             throws <span class="exceptions"><a href="../exceptions/ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Link.html#desiredCapabilities()">Link</a></code></span></div>
<div class="block">Returns the desired capabilities that the remote provided upon successfully opening the <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client"><code>Link</code></a>.
 If the attach has not completed yet this method will block to await the attach response which carries the
 remote desired capabilities.  If the remote provides no capabilities this method will return null.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Link.html#desiredCapabilities()">desiredCapabilities</a></code>&nbsp;in interface&nbsp;<code><a href="../Link.html" title="interface in org.apache.qpid.protonj2.client">Link</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a> extends <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client">Link</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a>&gt;&gt;</code></dd>
<dt>Returns:</dt>
<dd>any desired capabilities provided from the remote once the sender has successfully opened.</dd>
<dt>Throws:</dt>
<dd><code><a href="../exceptions/ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a></code> - if an error occurs while obtaining the <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client"><code>Link</code></a> remote desired capabilities.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="client()">
<h3>client</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ClientInstance.html" title="class in org.apache.qpid.protonj2.client.impl">ClientInstance</a></span>&nbsp;<span class="element-name">client</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Link.html#client()">client</a></code>&nbsp;in interface&nbsp;<code><a href="../Link.html" title="interface in org.apache.qpid.protonj2.client">Link</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a> extends <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client">Link</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a>&gt;&gt;</code></dd>
<dt>Returns:</dt>
<dd>the <a href="../Client.html" title="interface in org.apache.qpid.protonj2.client"><code>Client</code></a> instance that holds this session's <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client"><code>Link</code></a></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="connection()">
<h3>connection</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ClientConnection.html" title="class in org.apache.qpid.protonj2.client.impl">ClientConnection</a></span>&nbsp;<span class="element-name">connection</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Link.html#connection()">connection</a></code>&nbsp;in interface&nbsp;<code><a href="../Link.html" title="interface in org.apache.qpid.protonj2.client">Link</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a> extends <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client">Link</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a>&gt;&gt;</code></dd>
<dt>Returns:</dt>
<dd>the <a href="../Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a> instance that holds this session's <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client"><code>Link</code></a></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="session()">
<h3>session</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ClientSession.html" title="class in org.apache.qpid.protonj2.client.impl">ClientSession</a></span>&nbsp;<span class="element-name">session</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Link.html#session()">session</a></code>&nbsp;in interface&nbsp;<code><a href="../Link.html" title="interface in org.apache.qpid.protonj2.client">Link</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a> extends <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client">Link</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a>&gt;&gt;</code></dd>
<dt>Returns:</dt>
<dd>the <a href="../Session.html" title="interface in org.apache.qpid.protonj2.client"><code>Session</code></a> that created and holds this <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client"><code>Link</code></a>.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="openFuture()">
<h3>openFuture</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../futures/ClientFuture.html" title="class in org.apache.qpid.protonj2.client.futures">ClientFuture</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a>&gt;</span>&nbsp;<span class="element-name">openFuture</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Link.html#openFuture()">openFuture</a></code>&nbsp;in interface&nbsp;<code><a href="../Link.html" title="interface in org.apache.qpid.protonj2.client">Link</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a> extends <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client">Link</a>&lt;<a href="ClientLinkType.html" title="type parameter in ClientLinkType">LinkType</a>&gt;&gt;</code></dd>
<dt>Returns:</dt>
<dd>a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/Future.html" title="class or interface in java.util.concurrent" class="external-link"><code>Future</code></a> that will be completed when the remote opens this <a href="../Link.html" title="interface in org.apache.qpid.protonj2.client"><code>Link</code></a>.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="handleLocalOpen(ProtonType)">
<h3 id="handleLocalOpen(org.apache.qpid.protonj2.engine.Link)">handleLocalOpen</h3>
<div class="member-signature"><span class="modifiers">protected final</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">handleLocalOpen</span><wbr><span class="parameters">(<a href="ClientLinkType.html" title="type parameter in ClientLinkType">ProtonType</a>&nbsp;link)</span></div>
</section>
</li>
<li>
<section class="detail" id="handleLocalCloseOrDetach(ProtonType)">
<h3 id="handleLocalCloseOrDetach(org.apache.qpid.protonj2.engine.Link)">handleLocalCloseOrDetach</h3>
<div class="member-signature"><span class="modifiers">protected final</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">handleLocalCloseOrDetach</span><wbr><span class="parameters">(<a href="ClientLinkType.html" title="type parameter in ClientLinkType">ProtonType</a>&nbsp;link)</span></div>
</section>
</li>
<li>
<section class="detail" id="handleRemoteOpen(ProtonType)">
<h3 id="handleRemoteOpen(org.apache.qpid.protonj2.engine.Link)">handleRemoteOpen</h3>
<div class="member-signature"><span class="modifiers">protected final</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">handleRemoteOpen</span><wbr><span class="parameters">(<a href="ClientLinkType.html" title="type parameter in ClientLinkType">ProtonType</a>&nbsp;link)</span></div>
</section>
</li>
<li>
<section class="detail" id="handleRemoteCloseOrDetach(ProtonType)">
<h3 id="handleRemoteCloseOrDetach(org.apache.qpid.protonj2.engine.Link)">handleRemoteCloseOrDetach</h3>
<div class="member-signature"><span class="modifiers">protected final</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">handleRemoteCloseOrDetach</span><wbr><span class="parameters">(<a href="ClientLinkType.html" title="type parameter in ClientLinkType">ProtonType</a>&nbsp;link)</span></div>
</section>
</li>
<li>
<section class="detail" id="handleParentEndpointClosed(ProtonType)">
<h3 id="handleParentEndpointClosed(org.apache.qpid.protonj2.engine.Link)">handleParentEndpointClosed</h3>
<div class="member-signature"><span class="modifiers">protected final</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">handleParentEndpointClosed</span><wbr><span class="parameters">(<a href="ClientLinkType.html" title="type parameter in ClientLinkType">ProtonType</a>&nbsp;link)</span></div>
</section>
</li>
<li>
<section class="detail" id="handleEngineShutdown(org.apache.qpid.protonj2.engine.Engine)">
<h3>handleEngineShutdown</h3>
<div class="member-signature"><span class="modifiers">protected final</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">handleEngineShutdown</span><wbr><span class="parameters">(<a href="../../engine/Engine.html" title="interface in org.apache.qpid.protonj2.engine">Engine</a>&nbsp;engine)</span></div>
</section>
</li>
<li>
<section class="detail" id="immediateLinkShutdown(org.apache.qpid.protonj2.client.exceptions.ClientException)">
<h3>immediateLinkShutdown</h3>
<div class="member-signature"><span class="modifiers">protected final</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">immediateLinkShutdown</span><wbr><span class="parameters">(<a href="../exceptions/ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a>&nbsp;failureCause)</span></div>
</section>
</li>
<li>
<section class="detail" id="linkSpecificLocalOpenHandler()">
<h3>linkSpecificLocalOpenHandler</h3>
<div class="member-signature"><span class="modifiers">protected abstract</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">linkSpecificLocalOpenHandler</span>()</div>
</section>
</li>
<li>
<section class="detail" id="linkSpecificLocalCloseHandler()">
<h3>linkSpecificLocalCloseHandler</h3>
<div class="member-signature"><span class="modifiers">protected abstract</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">linkSpecificLocalCloseHandler</span>()</div>
</section>
</li>
<li>
<section class="detail" id="linkSpecificRemoteOpenHandler()">
<h3>linkSpecificRemoteOpenHandler</h3>
<div class="member-signature"><span class="modifiers">protected abstract</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">linkSpecificRemoteOpenHandler</span>()</div>
</section>
</li>
<li>
<section class="detail" id="linkSpecificRemoteCloseHandler()">
<h3>linkSpecificRemoteCloseHandler</h3>
<div class="member-signature"><span class="modifiers">protected abstract</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">linkSpecificRemoteCloseHandler</span>()</div>
</section>
</li>
<li>
<section class="detail" id="linkSpecificCleanupHandler(org.apache.qpid.protonj2.client.exceptions.ClientException)">
<h3>linkSpecificCleanupHandler</h3>
<div class="member-signature"><span class="modifiers">protected abstract</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">linkSpecificCleanupHandler</span><wbr><span class="parameters">(<a href="../exceptions/ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a>&nbsp;failureCause)</span></div>
</section>
</li>
<li>
<section class="detail" id="recreateLinkForReconnect()">
<h3>recreateLinkForReconnect</h3>
<div class="member-signature"><span class="modifiers">protected abstract</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">recreateLinkForReconnect</span>()</div>
</section>
</li>
<li>
<section class="detail" id="notClosedOrFailed(org.apache.qpid.protonj2.client.futures.ClientFuture)">
<h3>notClosedOrFailed</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">notClosedOrFailed</span><wbr><span class="parameters">(<a href="../futures/ClientFuture.html" title="class in org.apache.qpid.protonj2.client.futures">ClientFuture</a>&lt;?&gt;&nbsp;request)</span></div>
</section>
</li>
<li>
<section class="detail" id="notClosedOrFailed(org.apache.qpid.protonj2.client.futures.ClientFuture,ProtonType)">
<h3 id="notClosedOrFailed(org.apache.qpid.protonj2.client.futures.ClientFuture,org.apache.qpid.protonj2.engine.Link)">notClosedOrFailed</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">notClosedOrFailed</span><wbr><span class="parameters">(<a href="../futures/ClientFuture.html" title="class in org.apache.qpid.protonj2.client.futures">ClientFuture</a>&lt;?&gt;&nbsp;request,
 <a href="ClientLinkType.html" title="type parameter in ClientLinkType">ProtonType</a>&nbsp;protonLink)</span></div>
</section>
</li>
<li>
<section class="detail" id="checkClosedOrFailed()">
<h3>checkClosedOrFailed</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">checkClosedOrFailed</span>()
                            throws <span class="exceptions"><a href="../exceptions/ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a></span></div>
<dl class="notes">
<dt>Throws:</dt>
<dd><code><a href="../exceptions/ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="waitForOpenToComplete()">
<h3>waitForOpenToComplete</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">waitForOpenToComplete</span>()
                              throws <span class="exceptions"><a href="../exceptions/ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a></span></div>
<dl class="notes">
<dt>Throws:</dt>
<dd><code><a href="../exceptions/ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a></code></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>
