<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>Session (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, interface: Session">
<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/Session.html">Use</a></li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../../help-doc.html#class">Help</a></li>
</ul>
</div>
<div class="sub-nav">
<div>
<ul class="sub-nav-list">
<li>Summary:&nbsp;</li>
<li>Nested&nbsp;|&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method-summary">Method</a></li>
</ul>
<ul class="sub-nav-list">
<li>Detail:&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method-detail">Method</a></li>
</ul>
</div>
</div>
<!-- ========= END OF TOP NAVBAR ========= -->
<span class="skip-nav" id="skip-navbar-top"></span></nav>
</header>
<div class="flex-content">
<main role="main">
<!-- ======== START OF CLASS DATA ======== -->
<div class="header">
<div class="sub-title"><span class="package-label-in-type">Package</span>&nbsp;<a href="package-summary.html">org.apache.qpid.protonj2.client</a></div>
<h1 title="Interface Session" class="title">Interface Session</h1>
</div>
<section class="class-description" id="class-description">
<dl class="notes">
<dt>All Superinterfaces:</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></dd>
</dl>
<dl class="notes">
<dt>All Known Implementing Classes:</dt>
<dd><code><a href="impl/ClientSession.html" title="class in org.apache.qpid.protonj2.client.impl">ClientSession</a></code>, <code><a href="impl/ClientStreamSession.html" title="class in org.apache.qpid.protonj2.client.impl">ClientStreamSession</a></code></dd>
</dl>
<hr>
<div class="type-signature"><span class="modifiers">public interface </span><span class="element-name type-name-label">Session</span><span class="extends-implements">
extends <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></span></div>
<div class="block">Session object used to create <a href="Sender.html" title="interface in org.apache.qpid.protonj2.client"><code>Sender</code></a> and <a href="Receiver.html" title="interface in org.apache.qpid.protonj2.client"><code>Receiver</code></a> instances.
 <p>
 A session can serve as a context for a running transaction in which case care should be
 taken to ensure that work done is inside the scope of the transaction begin and end calls
 such as ensuring that receivers accept and settle before calling transaction commit if
 the work is meant to be within the transaction scope.</div>
</section>
<section class="summary">
<ul class="summary-list">
<!-- ========== METHOD SUMMARY =========== -->
<li>
<section class="method-summary" id="method-summary">
<h2>Method Summary</h2>
<div id="method-summary-table">
<div class="table-tabs" role="tablist" aria-orientation="horizontal"><button id="method-summary-table-tab0" role="tab" aria-selected="true" aria-controls="method-summary-table.tabpanel" tabindex="0" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table', 3)" class="active-table-tab">All Methods</button><button id="method-summary-table-tab2" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab2', 3)" class="table-tab">Instance Methods</button><button id="method-summary-table-tab3" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab3', 3)" class="table-tab">Abstract Methods</button></div>
<div id="method-summary-table.tabpanel" role="tabpanel">
<div class="summary-table three-column-summary" aria-labelledby="method-summary-table-tab0">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Method</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Session.html" title="interface in org.apache.qpid.protonj2.client">Session</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#beginTransaction()" class="member-name-link">beginTransaction</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Opens a new transaction scoped to this <a href="Session.html" title="interface in org.apache.qpid.protonj2.client"><code>Session</code></a> if one is not already active.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Client.html" title="interface in org.apache.qpid.protonj2.client">Client</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#client()" class="member-name-link">client</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>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#close()" class="member-name-link">close</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Requests a close of the <a href="Session.html" title="interface in org.apache.qpid.protonj2.client"><code>Session</code></a> at the remote and waits until the Session has been
 fully closed or until the configured <a href="SessionOptions.html#closeTimeout()"><code>SessionOptions.closeTimeout()</code></a> is exceeded.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Requests a close of the <a href="Session.html" title="interface in org.apache.qpid.protonj2.client"><code>Session</code></a> at the remote and waits until the Session has been
 fully closed or until the configured <a href="SessionOptions.html#closeTimeout()"><code>SessionOptions.closeTimeout()</code></a> is exceeded.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/Future.html" title="class or interface in java.util.concurrent" class="external-link">Future</a>&lt;<a href="Session.html" title="interface in org.apache.qpid.protonj2.client">Session</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#closeAsync()" class="member-name-link">closeAsync</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Requests a close of the <a href="Session.html" title="interface in org.apache.qpid.protonj2.client"><code>Session</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 session has been remotely closed or an error occurs.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/Future.html" title="class or interface in java.util.concurrent" class="external-link">Future</a>&lt;<a href="Session.html" title="interface in org.apache.qpid.protonj2.client">Session</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#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 method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Requests a close of the <a href="Session.html" title="interface in org.apache.qpid.protonj2.client"><code>Session</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 session has been remotely closed or an error occurs.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Session.html" title="interface in org.apache.qpid.protonj2.client">Session</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#commitTransaction()" class="member-name-link">commitTransaction</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Commit the currently active transaction in this Session.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#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-tab3">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>[]</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#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-tab3">
<div class="block">Returns the desired capabilities that the remote provided upon successfully opening the <a href="Session.html" title="interface in org.apache.qpid.protonj2.client"><code>Session</code></a>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#nextReceiver()" class="member-name-link">nextReceiver</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Waits indefinitely for a receiver created from this session to have a delivery ready for
 receipt.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#nextReceiver(long,java.util.concurrent.TimeUnit)" class="member-name-link">nextReceiver</a><wbr>(long&nbsp;timeout,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/TimeUnit.html" title="class or interface in java.util.concurrent" class="external-link">TimeUnit</a>&nbsp;unit)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Waits for the given duration for a receiver created from this session to have a delivery ready
 for receipt.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#nextReceiver(org.apache.qpid.protonj2.client.NextReceiverPolicy)" class="member-name-link">nextReceiver</a><wbr>(<a href="NextReceiverPolicy.html" title="enum in org.apache.qpid.protonj2.client">NextReceiverPolicy</a>&nbsp;policy)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Waits indefinitely for a receiver created from this session to have a delivery ready for
 receipt.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#nextReceiver(org.apache.qpid.protonj2.client.NextReceiverPolicy,long,java.util.concurrent.TimeUnit)" class="member-name-link">nextReceiver</a><wbr>(<a href="NextReceiverPolicy.html" title="enum in org.apache.qpid.protonj2.client">NextReceiverPolicy</a>&nbsp;policy,
 long&nbsp;timeout,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/TimeUnit.html" title="class or interface in java.util.concurrent" class="external-link">TimeUnit</a>&nbsp;unit)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Waits for the given duration for a receiver created from this session to have a delivery ready
 for receipt.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/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-tab3"><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-tab3">
<div class="block">Returns the offered capabilities that the remote provided upon successfully opening the <a href="Session.html" title="interface in org.apache.qpid.protonj2.client"><code>Session</code></a>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Sender.html" title="interface in org.apache.qpid.protonj2.client">Sender</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#openAnonymousSender()" class="member-name-link">openAnonymousSender</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Creates a sender that is established to the 'anonymous relay' and as such each
 message that is sent using this sender must specify an address in its destination
 address field.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Sender.html" title="interface in org.apache.qpid.protonj2.client">Sender</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#openAnonymousSender(org.apache.qpid.protonj2.client.SenderOptions)" class="member-name-link">openAnonymousSender</a><wbr>(<a href="SenderOptions.html" title="class in org.apache.qpid.protonj2.client">SenderOptions</a>&nbsp;senderOptions)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Creates a sender that is established to the 'anonymous relay' and as such each
 message that is sent using this sender must specify an address in its destination
 address field.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#openDurableReceiver(java.lang.String,java.lang.String)" class="member-name-link">openDurableReceiver</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;address,
 <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;subscriptionName)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Creates a receiver used to consume messages from the given node address and configure it
 such that the remote create a durable node.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#openDurableReceiver(java.lang.String,java.lang.String,org.apache.qpid.protonj2.client.ReceiverOptions)" class="member-name-link">openDurableReceiver</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;address,
 <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;subscriptionName,
 <a href="ReceiverOptions.html" title="class in org.apache.qpid.protonj2.client">ReceiverOptions</a>&nbsp;receiverOptions)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Creates a receiver used to consume messages from the given node address and configure it
 such that the remote create a durable node.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#openDynamicReceiver()" class="member-name-link">openDynamicReceiver</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Creates a dynamic receiver used to consume messages from the given node address.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#openDynamicReceiver(java.util.Map)" class="member-name-link">openDynamicReceiver</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="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;&nbsp;dynamicNodeProperties)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Creates a dynamic receiver used to consume messages from the given node address.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#openDynamicReceiver(java.util.Map,org.apache.qpid.protonj2.client.ReceiverOptions)" class="member-name-link">openDynamicReceiver</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="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;&nbsp;dynamicNodeProperties,
 <a href="ReceiverOptions.html" title="class in org.apache.qpid.protonj2.client">ReceiverOptions</a>&nbsp;receiverOptions)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Creates a dynamic receiver used to consume messages from the given node address.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#openDynamicReceiver(org.apache.qpid.protonj2.client.ReceiverOptions)" class="member-name-link">openDynamicReceiver</a><wbr>(<a href="ReceiverOptions.html" title="class in org.apache.qpid.protonj2.client">ReceiverOptions</a>&nbsp;receiverOptions)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Creates a dynamic receiver used to consume messages from the given node address.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/Future.html" title="class or interface in java.util.concurrent" class="external-link">Future</a>&lt;<a href="Session.html" title="interface in org.apache.qpid.protonj2.client">Session</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><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-tab3">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#openReceiver(java.lang.String)" class="member-name-link">openReceiver</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;address)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Creates a receiver used to consume messages from the given node address.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#openReceiver(java.lang.String,org.apache.qpid.protonj2.client.ReceiverOptions)" class="member-name-link">openReceiver</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;address,
 <a href="ReceiverOptions.html" title="class in org.apache.qpid.protonj2.client">ReceiverOptions</a>&nbsp;receiverOptions)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Creates a receiver used to consume messages from the given node address.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Sender.html" title="interface in org.apache.qpid.protonj2.client">Sender</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#openSender(java.lang.String)" class="member-name-link">openSender</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;address)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Creates a sender used to send messages to the given node address.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Sender.html" title="interface in org.apache.qpid.protonj2.client">Sender</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#openSender(java.lang.String,org.apache.qpid.protonj2.client.SenderOptions)" class="member-name-link">openSender</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;address,
 <a href="SenderOptions.html" title="class in org.apache.qpid.protonj2.client">SenderOptions</a>&nbsp;senderOptions)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Creates a sender used to send messages to the given node address.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/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-tab3"><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-tab3">
<div class="block">Returns the properties that the remote provided upon successfully opening the <a href="Session.html" title="interface in org.apache.qpid.protonj2.client"><code>Session</code></a>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Session.html" title="interface in org.apache.qpid.protonj2.client">Session</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#rollbackTransaction()" class="member-name-link">rollbackTransaction</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Roll back the currently active transaction in this Session.</div>
</div>
</div>
</div>
</div>
</section>
</li>
</ul>
</section>
<section class="details">
<ul class="details-list">
<!-- ============ METHOD DETAIL ========== -->
<li>
<section class="method-details" id="method-detail">
<h2>Method Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="client()">
<h3>client</h3>
<div class="member-signature"><span class="return-type"><a href="Client.html" title="interface in org.apache.qpid.protonj2.client">Client</a></span>&nbsp;<span class="element-name">client</span>()</div>
<dl class="notes">
<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="Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="connection()">
<h3>connection</h3>
<div class="member-signature"><span class="return-type"><a href="Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a></span>&nbsp;<span class="element-name">connection</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the <a href="Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a> that created and holds this <a href="Session.html" title="interface in org.apache.qpid.protonj2.client"><code>Session</code></a>.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="openFuture()">
<h3>openFuture</h3>
<div class="member-signature"><span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/Future.html" title="class or interface in java.util.concurrent" class="external-link">Future</a>&lt;<a href="Session.html" title="interface in org.apache.qpid.protonj2.client">Session</a>&gt;</span>&nbsp;<span class="element-name">openFuture</span>()</div>
<dl class="notes">
<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="Session.html" title="interface in org.apache.qpid.protonj2.client"><code>Session</code></a>.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="close()">
<h3>close</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">close</span>()</div>
<div class="block">Requests a close of the <a href="Session.html" title="interface in org.apache.qpid.protonj2.client"><code>Session</code></a> at the remote and waits until the Session has been
 fully closed or until the configured <a href="SessionOptions.html#closeTimeout()"><code>SessionOptions.closeTimeout()</code></a> 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>
</dl>
</section>
</li>
<li>
<section class="detail" id="close(org.apache.qpid.protonj2.client.ErrorCondition)">
<h3>close</h3>
<div class="member-signature"><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">Requests a close of the <a href="Session.html" title="interface in org.apache.qpid.protonj2.client"><code>Session</code></a> at the remote and waits until the Session has been
 fully closed or until the configured <a href="SessionOptions.html#closeTimeout()"><code>SessionOptions.closeTimeout()</code></a> is exceeded.</div>
<dl class="notes">
<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="closeAsync()">
<h3>closeAsync</h3>
<div class="member-signature"><span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/Future.html" title="class or interface in java.util.concurrent" class="external-link">Future</a>&lt;<a href="Session.html" title="interface in org.apache.qpid.protonj2.client">Session</a>&gt;</span>&nbsp;<span class="element-name">closeAsync</span>()</div>
<div class="block">Requests a close of the <a href="Session.html" title="interface in org.apache.qpid.protonj2.client"><code>Session</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 session has been remotely closed or an error occurs.</div>
<dl class="notes">
<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="Session.html" title="interface in org.apache.qpid.protonj2.client"><code>Session</code></a>.</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="return-type"><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="Session.html" title="interface in org.apache.qpid.protonj2.client">Session</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">Requests a close of the <a href="Session.html" title="interface in org.apache.qpid.protonj2.client"><code>Session</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 session has been remotely closed or an error occurs.</div>
<dl class="notes">
<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="Session.html" title="interface in org.apache.qpid.protonj2.client"><code>Session</code></a>.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="openReceiver(java.lang.String)">
<h3>openReceiver</h3>
<div class="member-signature"><span class="return-type"><a href="Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></span>&nbsp;<span class="element-name">openReceiver</span><wbr><span class="parameters">(<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;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">Creates a receiver used to consume messages from the given node address.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>address</code> - The source address to attach the consumer to.</dd>
<dt>Returns:</dt>
<dd>the newly created <a href="Receiver.html" title="interface in org.apache.qpid.protonj2.client"><code>Receiver</code></a></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 internal error occurs.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="openReceiver(java.lang.String,org.apache.qpid.protonj2.client.ReceiverOptions)">
<h3>openReceiver</h3>
<div class="member-signature"><span class="return-type"><a href="Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></span>&nbsp;<span class="element-name">openReceiver</span><wbr><span class="parameters">(<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;address,
 <a href="ReceiverOptions.html" title="class in org.apache.qpid.protonj2.client">ReceiverOptions</a>&nbsp;receiverOptions)</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">Creates a receiver used to consume messages from the given node address.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>address</code> - The source address to attach the consumer to.</dd>
<dd><code>receiverOptions</code> - The options for this receiver.</dd>
<dt>Returns:</dt>
<dd>the newly created <a href="Receiver.html" title="interface in org.apache.qpid.protonj2.client"><code>Receiver</code></a></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 internal error occurs.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="openDurableReceiver(java.lang.String,java.lang.String)">
<h3>openDurableReceiver</h3>
<div class="member-signature"><span class="return-type"><a href="Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></span>&nbsp;<span class="element-name">openDurableReceiver</span><wbr><span class="parameters">(<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;address,
 <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;subscriptionName)</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">Creates a receiver used to consume messages from the given node address and configure it
 such that the remote create a durable node.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>address</code> - The source address to attach the consumer to.</dd>
<dd><code>subscriptionName</code> - The name to give the subscription (link name).</dd>
<dt>Returns:</dt>
<dd>the newly created <a href="Receiver.html" title="interface in org.apache.qpid.protonj2.client"><code>Receiver</code></a></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 internal error occurs.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="openDurableReceiver(java.lang.String,java.lang.String,org.apache.qpid.protonj2.client.ReceiverOptions)">
<h3>openDurableReceiver</h3>
<div class="member-signature"><span class="return-type"><a href="Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></span>&nbsp;<span class="element-name">openDurableReceiver</span><wbr><span class="parameters">(<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;address,
 <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;subscriptionName,
 <a href="ReceiverOptions.html" title="class in org.apache.qpid.protonj2.client">ReceiverOptions</a>&nbsp;receiverOptions)</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">Creates a receiver used to consume messages from the given node address and configure it
 such that the remote create a durable node.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>address</code> - The source address to attach the consumer to.</dd>
<dd><code>subscriptionName</code> - The name to give the subscription (link name).</dd>
<dd><code>receiverOptions</code> - The options for this receiver.</dd>
<dt>Returns:</dt>
<dd>the newly created <a href="Receiver.html" title="interface in org.apache.qpid.protonj2.client"><code>Receiver</code></a></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 internal error occurs.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="openDynamicReceiver()">
<h3>openDynamicReceiver</h3>
<div class="member-signature"><span class="return-type"><a href="Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></span>&nbsp;<span class="element-name">openDynamicReceiver</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">Creates a dynamic receiver used to consume messages from the given node address.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the newly created <a href="Receiver.html" title="interface in org.apache.qpid.protonj2.client"><code>Receiver</code></a></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 internal error occurs.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="openDynamicReceiver(java.util.Map)">
<h3>openDynamicReceiver</h3>
<div class="member-signature"><span class="return-type"><a href="Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></span>&nbsp;<span class="element-name">openDynamicReceiver</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="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;&nbsp;dynamicNodeProperties)</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">Creates a dynamic receiver used to consume messages from the given node address.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>dynamicNodeProperties</code> - The dynamic node properties to be applied to the node created by the remote.</dd>
<dt>Returns:</dt>
<dd>the newly created <a href="Receiver.html" title="interface in org.apache.qpid.protonj2.client"><code>Receiver</code></a></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 internal error occurs.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="openDynamicReceiver(org.apache.qpid.protonj2.client.ReceiverOptions)">
<h3>openDynamicReceiver</h3>
<div class="member-signature"><span class="return-type"><a href="Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></span>&nbsp;<span class="element-name">openDynamicReceiver</span><wbr><span class="parameters">(<a href="ReceiverOptions.html" title="class in org.apache.qpid.protonj2.client">ReceiverOptions</a>&nbsp;receiverOptions)</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">Creates a dynamic receiver used to consume messages from the given node address.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>receiverOptions</code> - The options for this receiver.</dd>
<dt>Returns:</dt>
<dd>the newly created <a href="Receiver.html" title="interface in org.apache.qpid.protonj2.client"><code>Receiver</code></a></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 internal error occurs.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="openDynamicReceiver(java.util.Map,org.apache.qpid.protonj2.client.ReceiverOptions)">
<h3>openDynamicReceiver</h3>
<div class="member-signature"><span class="return-type"><a href="Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></span>&nbsp;<span class="element-name">openDynamicReceiver</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="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;&nbsp;dynamicNodeProperties,
 <a href="ReceiverOptions.html" title="class in org.apache.qpid.protonj2.client">ReceiverOptions</a>&nbsp;receiverOptions)</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">Creates a dynamic receiver used to consume messages from the given node address.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>dynamicNodeProperties</code> - The dynamic node properties to be applied to the node created by the remote.</dd>
<dd><code>receiverOptions</code> - The options for this receiver.</dd>
<dt>Returns:</dt>
<dd>the newly created <a href="Receiver.html" title="interface in org.apache.qpid.protonj2.client"><code>Receiver</code></a></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 internal error occurs.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="openSender(java.lang.String)">
<h3>openSender</h3>
<div class="member-signature"><span class="return-type"><a href="Sender.html" title="interface in org.apache.qpid.protonj2.client">Sender</a></span>&nbsp;<span class="element-name">openSender</span><wbr><span class="parameters">(<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;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">Creates a sender used to send messages to the given node address. If no
 address (i.e null) is specified then a sender will be established to the
 'anonymous relay' and each message must specify its destination address.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>address</code> - The target address to attach to, or null to attach to the
            anonymous relay.</dd>
<dt>Returns:</dt>
<dd>the newly created <a href="Sender.html" title="interface in org.apache.qpid.protonj2.client"><code>Sender</code></a>.</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 internal error occurs.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="openSender(java.lang.String,org.apache.qpid.protonj2.client.SenderOptions)">
<h3>openSender</h3>
<div class="member-signature"><span class="return-type"><a href="Sender.html" title="interface in org.apache.qpid.protonj2.client">Sender</a></span>&nbsp;<span class="element-name">openSender</span><wbr><span class="parameters">(<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;address,
 <a href="SenderOptions.html" title="class in org.apache.qpid.protonj2.client">SenderOptions</a>&nbsp;senderOptions)</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">Creates a sender used to send messages to the given node address. If no
 address (i.e null) is specified then a sender will be established to the
 'anonymous relay' and each message must specify its destination address.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>address</code> - The target address to attach to, or null to attach to the
            anonymous relay.</dd>
<dd><code>senderOptions</code> - The options for this sender.</dd>
<dt>Returns:</dt>
<dd>the newly created <a href="Sender.html" title="interface in org.apache.qpid.protonj2.client"><code>Sender</code></a>.</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 internal error occurs.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="openAnonymousSender()">
<h3>openAnonymousSender</h3>
<div class="member-signature"><span class="return-type"><a href="Sender.html" title="interface in org.apache.qpid.protonj2.client">Sender</a></span>&nbsp;<span class="element-name">openAnonymousSender</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">Creates a sender that is established to the 'anonymous relay' and as such each
 message that is sent using this sender must specify an address in its destination
 address field.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the newly created <a href="Sender.html" title="interface in org.apache.qpid.protonj2.client"><code>Sender</code></a>.</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 internal error occurs.</dd>
<dd><code><a href="exceptions/ClientUnsupportedOperationException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientUnsupportedOperationException</a></code> - if the remote did not signal support for anonymous relays.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="openAnonymousSender(org.apache.qpid.protonj2.client.SenderOptions)">
<h3>openAnonymousSender</h3>
<div class="member-signature"><span class="return-type"><a href="Sender.html" title="interface in org.apache.qpid.protonj2.client">Sender</a></span>&nbsp;<span class="element-name">openAnonymousSender</span><wbr><span class="parameters">(<a href="SenderOptions.html" title="class in org.apache.qpid.protonj2.client">SenderOptions</a>&nbsp;senderOptions)</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">Creates a sender that is established to the 'anonymous relay' and as such each
 message that is sent using this sender must specify an address in its destination
 address field.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>senderOptions</code> - The options for this sender.</dd>
<dt>Returns:</dt>
<dd>the newly created <a href="Sender.html" title="interface in org.apache.qpid.protonj2.client"><code>Sender</code></a>.</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 internal error occurs.</dd>
<dd><code><a href="exceptions/ClientUnsupportedOperationException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientUnsupportedOperationException</a></code> - if the remote did not signal support for anonymous relays.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="properties()">
<h3>properties</h3>
<div class="member-signature"><span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/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">Returns the properties that the remote provided upon successfully opening the <a href="Session.html" title="interface in org.apache.qpid.protonj2.client"><code>Session</code></a>.  If the
 open has not completed yet this method will block to await the open response which carries the remote
 properties.  If the remote provides no properties this method will return null.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>any properties provided from the remote once the session 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="Session.html" title="interface in org.apache.qpid.protonj2.client"><code>Session</code></a> remote properties.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="offeredCapabilities()">
<h3>offeredCapabilities</h3>
<div class="member-signature"><span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>[]</span>&nbsp;<span class="element-name">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">Returns the offered capabilities that the remote provided upon successfully opening the <a href="Session.html" title="interface in org.apache.qpid.protonj2.client"><code>Session</code></a>.
 If the open has not completed yet this method will block to await the open response which carries the
 remote offered capabilities.  If the remote provides no capabilities this method will return null.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>any capabilities provided from the remote once the session 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="Session.html" title="interface in org.apache.qpid.protonj2.client"><code>Session</code></a> remote offered capabilities.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="desiredCapabilities()">
<h3>desiredCapabilities</h3>
<div class="member-signature"><span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>[]</span>&nbsp;<span class="element-name">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">Returns the desired capabilities that the remote provided upon successfully opening the <a href="Session.html" title="interface in org.apache.qpid.protonj2.client"><code>Session</code></a>.
 If the open has not completed yet this method will block to await the open response which carries the
 remote desired capabilities.  If the remote provides no capabilities this method will return null.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>any desired capabilities provided from the remote once the session 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="Session.html" title="interface in org.apache.qpid.protonj2.client"><code>Session</code></a> remote desired capabilities.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="beginTransaction()">
<h3>beginTransaction</h3>
<div class="member-signature"><span class="return-type"><a href="Session.html" title="interface in org.apache.qpid.protonj2.client">Session</a></span>&nbsp;<span class="element-name">beginTransaction</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">Opens a new transaction scoped to this <a href="Session.html" title="interface in org.apache.qpid.protonj2.client"><code>Session</code></a> if one is not already active.

 A <a href="Session.html" title="interface in org.apache.qpid.protonj2.client"><code>Session</code></a> that has an active transaction will perform all sends and all delivery dispositions
 under that active transaction.  If the user wishes to send with the same session but outside of a
 transaction the user must commit the active transaction and not request that a new one be started.
 A session can only have one active transaction at a time and as such any call to begin while there is
 a currently active transaction will throw an <a href="exceptions/ClientIllegalStateException.html" title="class in org.apache.qpid.protonj2.client.exceptions"><code>ClientIllegalStateException</code></a> to indicate that
 the operation being requested is not valid at that time.

 This is a blocking method that will return successfully only after a new transaction has been started.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>this <a href="Session.html" title="interface in org.apache.qpid.protonj2.client"><code>Session</code></a> instance.</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 attempting to begin a new transaction.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="commitTransaction()">
<h3>commitTransaction</h3>
<div class="member-signature"><span class="return-type"><a href="Session.html" title="interface in org.apache.qpid.protonj2.client">Session</a></span>&nbsp;<span class="element-name">commitTransaction</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">Commit the currently active transaction in this Session.

 Commit the currently active transaction in this Session but does not start a new transaction
 automatically.  If there is no current transaction this method will throw an <a href="exceptions/ClientTransactionNotActiveException.html" title="class in org.apache.qpid.protonj2.client.exceptions"><code>ClientTransactionNotActiveException</code></a>
 to indicate this error.  If the active transaction has entered an in doubt state or was remotely rolled
 back this method will throw an error to indicate that the commit failed and that a new transaction
 need to be started by the user.  When a transaction rolled back error occurs the user should assume that
 all work performed under that transaction has failed and will need to be attempted under a new transaction.

 This is a blocking method that will return successfully only after the current transaction has been committed.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>this <a href="Session.html" title="interface in org.apache.qpid.protonj2.client"><code>Session</code></a> instance.</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 attempting to commit the current transaction.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="rollbackTransaction()">
<h3>rollbackTransaction</h3>
<div class="member-signature"><span class="return-type"><a href="Session.html" title="interface in org.apache.qpid.protonj2.client">Session</a></span>&nbsp;<span class="element-name">rollbackTransaction</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">Roll back the currently active transaction in this Session.

 Roll back the currently active transaction in this Session but does not automatically start a new
 transaction.  If there is no current transaction this method will throw an <a href="exceptions/ClientTransactionNotActiveException.html" title="class in org.apache.qpid.protonj2.client.exceptions"><code>ClientTransactionNotActiveException</code></a>
 to indicate this error.  If the active transaction has entered an in doubt state or was remotely rolled
 back this method will throw an error to indicate that the roll back failed and that a new transaction need
 to be started by the user.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>this <a href="Session.html" title="interface in org.apache.qpid.protonj2.client"><code>Session</code></a> instance.</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 attempting to roll back the current transaction.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="nextReceiver()">
<h3>nextReceiver</h3>
<div class="member-signature"><span class="return-type"><a href="Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></span>&nbsp;<span class="element-name">nextReceiver</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">Waits indefinitely for a receiver created from this session to have a delivery ready for
 receipt. The selection of the next receiver when more than one exits which has pending
 deliveries is based upon the configured value of the <a href="SessionOptions.html#defaultNextReceiverPolicy()"><code>SessionOptions.defaultNextReceiverPolicy()</code></a>
 used to create this session or if none was provided then the value is taken from the value
 of the <a href="ConnectionOptions.html#defaultNextReceiverPolicy()"><code>ConnectionOptions.defaultNextReceiverPolicy()</code></a>.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the next receiver that has a pending delivery available based on policy.</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 internal error occurs.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="nextReceiver(org.apache.qpid.protonj2.client.NextReceiverPolicy)">
<h3>nextReceiver</h3>
<div class="member-signature"><span class="return-type"><a href="Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></span>&nbsp;<span class="element-name">nextReceiver</span><wbr><span class="parameters">(<a href="NextReceiverPolicy.html" title="enum in org.apache.qpid.protonj2.client">NextReceiverPolicy</a>&nbsp;policy)</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">Waits indefinitely for a receiver created from this session to have a delivery ready for
 receipt. The selection of the next receiver when more than one exits which has pending
 deliveries is based upon the value of the <a href="NextReceiverPolicy.html" title="enum in org.apache.qpid.protonj2.client"><code>NextReceiverPolicy</code></a> that is provided by
 the caller.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>policy</code> - The policy to apply when selecting the next receiver.</dd>
<dt>Returns:</dt>
<dd>the next receiver that has a pending delivery available based on policy.</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 internal error occurs.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="nextReceiver(long,java.util.concurrent.TimeUnit)">
<h3>nextReceiver</h3>
<div class="member-signature"><span class="return-type"><a href="Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></span>&nbsp;<span class="element-name">nextReceiver</span><wbr><span class="parameters">(long&nbsp;timeout,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/TimeUnit.html" title="class or interface in java.util.concurrent" class="external-link">TimeUnit</a>&nbsp;unit)</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">Waits for the given duration for a receiver created from this session to have a delivery ready
 for receipt. The selection of the next receiver when more than one exits which has pending
 deliveries is based upon the configured value of the <a href="SessionOptions.html#defaultNextReceiverPolicy()"><code>SessionOptions.defaultNextReceiverPolicy()</code></a>
 used to create this session or if none was provided then the value is taken from the value
 of the <a href="ConnectionOptions.html#defaultNextReceiverPolicy()"><code>ConnectionOptions.defaultNextReceiverPolicy()</code></a>. If no receiver has an available
 delivery within the given timeout this method returns null.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>timeout</code> - The timeout value used to control how long the method waits for a new <a href="Delivery.html" title="interface in org.apache.qpid.protonj2.client"><code>Delivery</code></a> to be available.</dd>
<dd><code>unit</code> - The unit of time that the given timeout represents.</dd>
<dt>Returns:</dt>
<dd>the next receiver that has a pending delivery available based on policy.</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 internal error occurs.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="nextReceiver(org.apache.qpid.protonj2.client.NextReceiverPolicy,long,java.util.concurrent.TimeUnit)">
<h3>nextReceiver</h3>
<div class="member-signature"><span class="return-type"><a href="Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></span>&nbsp;<span class="element-name">nextReceiver</span><wbr><span class="parameters">(<a href="NextReceiverPolicy.html" title="enum in org.apache.qpid.protonj2.client">NextReceiverPolicy</a>&nbsp;policy,
 long&nbsp;timeout,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/TimeUnit.html" title="class or interface in java.util.concurrent" class="external-link">TimeUnit</a>&nbsp;unit)</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">Waits for the given duration for a receiver created from this session to have a delivery ready
 for receipt. The selection of the next receiver when more than one exits which has pending
 deliveries is based upon the value of the <a href="NextReceiverPolicy.html" title="enum in org.apache.qpid.protonj2.client"><code>NextReceiverPolicy</code></a> provided by the caller. If
 no receiver has an available delivery within the given timeout this method returns null.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>policy</code> - The policy to apply when selecting the next receiver.</dd>
<dd><code>timeout</code> - The timeout value used to control how long the method waits for a new <a href="Delivery.html" title="interface in org.apache.qpid.protonj2.client"><code>Delivery</code></a> to be available.</dd>
<dd><code>unit</code> - The unit of time that the given timeout represents.</dd>
<dt>Returns:</dt>
<dd>the next receiver that has a pending delivery available based on policy.</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 internal error occurs.</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>
