<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>Uses of Interface org.apache.qpid.protonj2.client.Connection (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="use: package: org.apache.qpid.protonj2.client, interface: Connection">
<meta name="generator" content="javadoc/ClassUseWriter">
<link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
<script type="text/javascript" src="../../../../../../script.js"></script>
</head>
<body class="class-use-page">
<script type="text/javascript"></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><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.client">Class</a></li>
<li class="nav-bar-cell1-rev">Use</li>
<li><a href="../package-tree.html">Tree</a></li>
<li><a href="../../../../../../help-doc.html#use">Help</a></li>
</ul>
</div>
<!-- ========= END OF TOP NAVBAR ========= -->
<span class="skip-nav" id="skip-navbar-top"></span></nav>
</header>
<div class="flex-content">
<main role="main">
<div class="header">
<h1 title="Uses of Interface org.apache.qpid.protonj2.client.Connection" class="title">Uses of Interface<br>org.apache.qpid.protonj2.client.Connection</h1>
</div>
<div class="caption"><span>Packages that use <a href="../Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a></span></div>
<div class="summary-table two-column-summary">
<div class="table-header col-first">Package</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><a href="#org.apache.qpid.protonj2.client">org.apache.qpid.protonj2.client</a></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><a href="#org.apache.qpid.protonj2.client.impl">org.apache.qpid.protonj2.client.impl</a></div>
<div class="col-last odd-row-color">&nbsp;</div>
</div>
<section class="class-uses">
<ul class="block-list">
<li>
<section class="detail" id="org.apache.qpid.protonj2.client">
<h2>Uses of <a href="../Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a> in <a href="../package-summary.html">org.apache.qpid.protonj2.client</a></h2>
<div class="caption"><span>Methods in <a href="../package-summary.html">org.apache.qpid.protonj2.client</a> that return <a href="../Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a></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">Method</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">Client.</span><code><a href="../Client.html#connect(java.lang.String)" class="member-name-link">connect</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;host)</code></div>
<div class="col-last even-row-color">
<div class="block">Connect to the specified host, using the default port, without credentials and with all
 connection options set to their defaults.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Client.</span><code><a href="../Client.html#connect(java.lang.String,int)" class="member-name-link">connect</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;host,
 int&nbsp;port)</code></div>
<div class="col-last odd-row-color">
<div class="block">Connect to the specified host and port, without credentials and with all
 connection options set to their defaults.</div>
</div>
<div class="col-first even-row-color"><code><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">Client.</span><code><a href="../Client.html#connect(java.lang.String,int,org.apache.qpid.protonj2.client.ConnectionOptions)" class="member-name-link">connect</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;host,
 int&nbsp;port,
 <a href="../ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a>&nbsp;options)</code></div>
<div class="col-last even-row-color">
<div class="block">Connect to the specified host and port, with given connection options.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Client.</span><code><a href="../Client.html#connect(java.lang.String,org.apache.qpid.protonj2.client.ConnectionOptions)" class="member-name-link">connect</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;host,
 <a href="../ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a>&nbsp;options)</code></div>
<div class="col-last odd-row-color">
<div class="block">Connect to the specified host, using the default port, without credentials and with all
 connection options set to their defaults.</div>
</div>
<div class="col-first even-row-color"><code><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">Link.</span><code><a href="../Link.html#connection()" class="member-name-link">connection</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Session.</span><code><a href="../Session.html#connection()" class="member-name-link">connection</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
</div>
<div class="caption"><span>Methods in <a href="../package-summary.html">org.apache.qpid.protonj2.client</a> that return types with arguments of type <a href="../Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a></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">Method</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code><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">Future</a>&lt;<a href="../Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a>&gt;</code></div>
<div class="col-second even-row-color"><span class="type-name-label">Connection.</span><code><a href="../Connection.html#closeAsync()" class="member-name-link">closeAsync</a>()</code></div>
<div class="col-last even-row-color">
<div class="block">Requests a close of the <a href="../Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a> 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 Connection has been fully closed.</div>
</div>
<div class="col-first odd-row-color"><code><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">Future</a>&lt;<a href="../Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a>&gt;</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Connection.</span><code><a href="../Connection.html#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 odd-row-color">
<div class="block">Requests a close of the <a href="../Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a> 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 Connection has been fully closed.</div>
</div>
<div class="col-first even-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/function/BiConsumer.html" title="class or interface in java.util.function" class="external-link">BiConsumer</a>&lt;<a href="../Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a>,<wbr><a href="../ConnectionEvent.html" title="class in org.apache.qpid.protonj2.client">ConnectionEvent</a>&gt;</code></div>
<div class="col-second even-row-color"><span class="type-name-label">ConnectionOptions.</span><code><a href="../ConnectionOptions.html#connectedHandler()" class="member-name-link">connectedHandler</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/function/BiConsumer.html" title="class or interface in java.util.function" class="external-link">BiConsumer</a>&lt;<a href="../Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a>,<wbr><a href="../DisconnectionEvent.html" title="class in org.apache.qpid.protonj2.client">DisconnectionEvent</a>&gt;</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ConnectionOptions.</span><code><a href="../ConnectionOptions.html#disconnectedHandler()" class="member-name-link">disconnectedHandler</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/function/BiConsumer.html" title="class or interface in java.util.function" class="external-link">BiConsumer</a>&lt;<a href="../Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a>,<wbr><a href="../DisconnectionEvent.html" title="class in org.apache.qpid.protonj2.client">DisconnectionEvent</a>&gt;</code></div>
<div class="col-second even-row-color"><span class="type-name-label">ConnectionOptions.</span><code><a href="../ConnectionOptions.html#interruptedHandler()" class="member-name-link">interruptedHandler</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><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">Future</a>&lt;<a href="../Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a>&gt;</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Connection.</span><code><a href="../Connection.html#openFuture()" class="member-name-link">openFuture</a>()</code></div>
<div class="col-last odd-row-color">
<div class="block">When a <a href="../Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a> is created it may not be opened on the remote peer, the future returned
 from this method allows the caller to await the completion of the Connection open by the remote before
 proceeding on to other messaging operations.</div>
</div>
<div class="col-first even-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/function/BiConsumer.html" title="class or interface in java.util.function" class="external-link">BiConsumer</a>&lt;<a href="../Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a>,<wbr><a href="../ConnectionEvent.html" title="class in org.apache.qpid.protonj2.client">ConnectionEvent</a>&gt;</code></div>
<div class="col-second even-row-color"><span class="type-name-label">ConnectionOptions.</span><code><a href="../ConnectionOptions.html#reconnectedHandler()" class="member-name-link">reconnectedHandler</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
</div>
<div class="caption"><span>Method parameters in <a href="../package-summary.html">org.apache.qpid.protonj2.client</a> with type arguments of type <a href="../Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a></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">Method</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code><a href="../ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ConnectionOptions.</span><code><a href="../ConnectionOptions.html#connectedHandler(java.util.function.BiConsumer)" class="member-name-link">connectedHandler</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/function/BiConsumer.html" title="class or interface in java.util.function" class="external-link">BiConsumer</a>&lt;<a href="../Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a>,<wbr><a href="../ConnectionEvent.html" title="class in org.apache.qpid.protonj2.client">ConnectionEvent</a>&gt;&nbsp;connectedHandler)</code></div>
<div class="col-last even-row-color">
<div class="block">Configures a handler that will be notified when a <a href="../Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a> has established.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ConnectionOptions.</span><code><a href="../ConnectionOptions.html#disconnectedHandler(java.util.function.BiConsumer)" class="member-name-link">disconnectedHandler</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/function/BiConsumer.html" title="class or interface in java.util.function" class="external-link">BiConsumer</a>&lt;<a href="../Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a>,<wbr><a href="../DisconnectionEvent.html" title="class in org.apache.qpid.protonj2.client">DisconnectionEvent</a>&gt;&nbsp;disconnectedHandler)</code></div>
<div class="col-last odd-row-color">
<div class="block">Configures a handler that will be notified when the connection has failed and cannot be recovered
 should reconnect be enabled.</div>
</div>
<div class="col-first even-row-color"><code><a href="../ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ConnectionOptions.</span><code><a href="../ConnectionOptions.html#interruptedHandler(java.util.function.BiConsumer)" class="member-name-link">interruptedHandler</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/function/BiConsumer.html" title="class or interface in java.util.function" class="external-link">BiConsumer</a>&lt;<a href="../Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a>,<wbr><a href="../DisconnectionEvent.html" title="class in org.apache.qpid.protonj2.client">DisconnectionEvent</a>&gt;&nbsp;interruptedHandler)</code></div>
<div class="col-last even-row-color">
<div class="block">Configures a handler that will be notified when the current <a href="../Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a> experiences an
 interruption.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ConnectionOptions.</span><code><a href="../ConnectionOptions.html#reconnectedHandler(java.util.function.BiConsumer)" class="member-name-link">reconnectedHandler</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/function/BiConsumer.html" title="class or interface in java.util.function" class="external-link">BiConsumer</a>&lt;<a href="../Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a>,<wbr><a href="../ConnectionEvent.html" title="class in org.apache.qpid.protonj2.client">ConnectionEvent</a>&gt;&nbsp;reconnectedHandler)</code></div>
<div class="col-last odd-row-color">
<div class="block">Configures a handler that will be notified when a <a href="../Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a> that has previously
 experienced and interruption has been reconnected to a remote based on the reconnection
 configuration.</div>
</div>
</div>
</section>
</li>
<li>
<section class="detail" id="org.apache.qpid.protonj2.client.impl">
<h2>Uses of <a href="../Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a> in <a href="../impl/package-summary.html">org.apache.qpid.protonj2.client.impl</a></h2>
<div class="caption"><span>Classes in <a href="../impl/package-summary.html">org.apache.qpid.protonj2.client.impl</a> that implement <a href="../Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a></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">Class</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code>final class&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="../impl/ClientConnection.html" class="type-name-link" title="class in org.apache.qpid.protonj2.client.impl">ClientConnection</a></code></div>
<div class="col-last even-row-color">
<div class="block">A <a href="../Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a> implementation that uses the Proton engine for AMQP protocol support.</div>
</div>
</div>
<div class="caption"><span>Methods in <a href="../impl/package-summary.html">org.apache.qpid.protonj2.client.impl</a> that return <a href="../Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a></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">Method</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientInstance.</span><code><a href="../impl/ClientInstance.html#connect(java.lang.String)" class="member-name-link">connect</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;host)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientInstance.</span><code><a href="../impl/ClientInstance.html#connect(java.lang.String,int)" class="member-name-link">connect</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;host,
 int&nbsp;port)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientInstance.</span><code><a href="../impl/ClientInstance.html#connect(java.lang.String,int,org.apache.qpid.protonj2.client.ConnectionOptions)" class="member-name-link">connect</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;host,
 int&nbsp;port,
 <a href="../ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a>&nbsp;options)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientInstance.</span><code><a href="../impl/ClientInstance.html#connect(java.lang.String,org.apache.qpid.protonj2.client.ConnectionOptions)" class="member-name-link">connect</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;host,
 <a href="../ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a>&nbsp;options)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
</div>
<div class="caption"><span>Methods in <a href="../impl/package-summary.html">org.apache.qpid.protonj2.client.impl</a> that return types with arguments of type <a href="../Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a></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">Method</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code><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">Future</a>&lt;<a href="../Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a>&gt;</code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientConnection.</span><code><a href="../impl/ClientConnection.html#closeAsync()" class="member-name-link">closeAsync</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><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">Future</a>&lt;<a href="../Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a>&gt;</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientConnection.</span><code><a href="../impl/ClientConnection.html#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 odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><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">Future</a>&lt;<a href="../Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a>&gt;</code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientConnection.</span><code><a href="../impl/ClientConnection.html#openFuture()" class="member-name-link">openFuture</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
</div>
</section>
</li>
</ul>
</section>
</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>
