<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>Message (Qpid ProtonJ2 Parent 1.0.0-M19 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: Message">
<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/Message.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 Message" class="title">Interface Message&lt;E&gt;</h1>
</div>
<section class="class-description" id="class-description">
<dl class="notes">
<dt>Type Parameters:</dt>
<dd><code>E</code> - The type of the message body that this message carries</dd>
</dl>
<dl class="notes">
<dt>All Known Subinterfaces:</dt>
<dd><code><a href="AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client">AdvancedMessage</a>&lt;E&gt;</code>, <code><a href="StreamReceiverMessage.html" title="interface in org.apache.qpid.protonj2.client">StreamReceiverMessage</a></code>, <code><a href="StreamSenderMessage.html" title="interface in org.apache.qpid.protonj2.client">StreamSenderMessage</a></code></dd>
</dl>
<dl class="notes">
<dt>All Known Implementing Classes:</dt>
<dd><code><a href="impl/ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl">ClientMessage</a></code>, <code><a href="impl/ClientStreamReceiverMessage.html" title="class in org.apache.qpid.protonj2.client.impl">ClientStreamReceiverMessage</a></code></dd>
</dl>
<hr>
<div class="type-signature"><span class="modifiers">public interface </span><span class="element-name type-name-label">Message&lt;E&gt;</span></div>
<div class="block">Message object that provides a high level abstraction to raw AMQP types</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-tab1" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab1', 3)" class="table-tab">Static Methods</button><button id="method-summary-table-tab2" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab2', 3)" class="table-tab">Instance Methods</button><button id="method-summary-table-tab3" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab3', 3)" class="table-tab">Abstract Methods</button><button id="method-summary-table-tab5" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab5', 3)" class="table-tab">Default 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>long</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#absoluteExpiryTime()" class="member-name-link">absoluteExpiryTime</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="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="Message.html" title="type parameter in Message">E</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="#absoluteExpiryTime(long)" class="member-name-link">absoluteExpiryTime</a><wbr>(long&nbsp;expiryTime)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Sets the absolute expiration time value to assign to this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</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="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></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#annotation(java.lang.String)" class="member-name-link">annotation</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;key)</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 requested message annotation value from this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> if it exists
 or returns null otherwise.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="Message.html" title="type parameter in Message">E</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="#annotation(java.lang.String,java.lang.Object)" class="member-name-link">annotation</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;key,
 <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>&nbsp;value)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Sets the given message annotation value at the given key, replacing any previous value
 that was assigned to this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</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="Message.html" title="type parameter in Message">E</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#body()" class="member-name-link">body</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 body value that is conveyed in this message or null if no body was set locally
 or sent from the remote if this is an incoming message.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="Message.html" title="type parameter in Message">E</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="#body(E)" class="member-name-link">body</a><wbr>(<a href="Message.html" title="type parameter in Message">E</a>&nbsp;value)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Sets the body value that is to be conveyed to the remote when this message is sent.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#contentEncoding()" class="member-name-link">contentEncoding</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="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;?&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#contentEncoding(java.lang.String)" class="member-name-link">contentEncoding</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;contentEncoding)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Sets the contentEncoding value to assign to this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</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="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="#contentType()" class="member-name-link">contentType</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="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="Message.html" title="type parameter in Message">E</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="#contentType(java.lang.String)" class="member-name-link">contentType</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;contentType)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Sets the contentType value to assign to this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</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="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></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#correlationId()" class="member-name-link">correlationId</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="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="Message.html" title="type parameter in Message">E</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="#correlationId(java.lang.Object)" class="member-name-link">correlationId</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>&nbsp;correlationId)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Sets the correlationId value to assign to this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1"><code>static &lt;E&gt;&nbsp;<a href="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;E&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1"><code><a href="#create()" class="member-name-link">create</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1">
<div class="block">Create and return an <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> that will carry no body <a href="../types/messaging/Section.html" title="interface in org.apache.qpid.protonj2.types.messaging"><code>Section</code></a>
 unless one is assigned by the caller.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1"><code>static <a href="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;byte[]&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1"><code><a href="#create(byte%5B%5D)" class="member-name-link">create</a><wbr>(byte[]&nbsp;body)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1">
<div class="block">Create and return an <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> that will wrap the given byte array in
 an <a href="../types/messaging/Data.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>Data</code></a> section.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1"><code>static &lt;E&gt;&nbsp;<a href="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;E&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1"><code><a href="#create(E)" class="member-name-link">create</a><wbr>(E&nbsp;body)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1">
<div class="block">Create and return an <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> that will wrap the given <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"><code>Object</code></a> in
 an <a href="../types/messaging/AmqpValue.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>AmqpValue</code></a> section.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1"><code>static &lt;E&gt;&nbsp;<a href="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1"><code><a href="#create(java.util.List)" class="member-name-link">create</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;&nbsp;body)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1">
<div class="block">Create and return an <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> that will wrap the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link"><code>List</code></a> in
 an <a href="../types/messaging/AmqpSequence.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>AmqpSequence</code></a> section.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1"><code>static &lt;K,<wbr>
V&gt;&nbsp;<a href="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<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;K,<wbr>V&gt;&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1"><code><a href="#create(java.util.Map)" class="member-name-link">create</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;K,<wbr>V&gt;&nbsp;body)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1">
<div class="block">Create and return an <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> that will wrap the given <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"><code>Map</code></a> in
 an <a href="../types/messaging/AmqpValue.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>AmqpValue</code></a> section.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>long</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#creationTime()" class="member-name-link">creationTime</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="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="Message.html" title="type parameter in Message">E</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="#creationTime(long)" class="member-name-link">creationTime</a><wbr>(long&nbsp;createTime)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Sets the creation time value to assign to this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>long</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#deliveryCount()" class="member-name-link">deliveryCount</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="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="Message.html" title="type parameter in Message">E</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="#deliveryCount(long)" class="member-name-link">deliveryCount</a><wbr>(long&nbsp;deliveryCount)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Sets the value to assign to the delivery count field of this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#durable()" class="member-name-link">durable</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">For an message being sent this method returns the current state of the
 durable flag on the message.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="Message.html" title="type parameter in Message">E</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="#durable(boolean)" class="member-name-link">durable</a><wbr>(boolean&nbsp;durable)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Controls if the message is marked as durable when sent.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#firstAcquirer()" class="member-name-link">firstAcquirer</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="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="Message.html" title="type parameter in Message">E</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="#firstAcquirer(boolean)" class="member-name-link">firstAcquirer</a><wbr>(boolean&nbsp;firstAcquirer)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Sets the value to assign to the first acquirer field of this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#footer(java.lang.String)" class="member-name-link">footer</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;key)</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 requested footer value from this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> if it exists or returns
 <code>null</code> otherwise.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="Message.html" title="type parameter in Message">E</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="#footer(java.lang.String,java.lang.Object)" class="member-name-link">footer</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;key,
 <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>&nbsp;value)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Sets the given footer value at the given key, replacing any previous value
 that was assigned to this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</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="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="Message.html" title="type parameter in Message">E</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="#forEachAnnotation(java.util.function.BiConsumer)" class="member-name-link">forEachAnnotation</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="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;action)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Invokes the given <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"><code>BiConsumer</code></a> on each message annotation entry carried in this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</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="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="Message.html" title="type parameter in Message">E</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="#forEachFooter(java.util.function.BiConsumer)" class="member-name-link">forEachFooter</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="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;action)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Invokes the given <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"><code>BiConsumer</code></a> on each footer entry carried in this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</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="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="Message.html" title="type parameter in Message">E</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="#forEachProperty(java.util.function.BiConsumer)" class="member-name-link">forEachProperty</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="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;action)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Invokes the given <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"><code>BiConsumer</code></a> on each application property entry carried in this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</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="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="#groupId()" class="member-name-link">groupId</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="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="Message.html" title="type parameter in Message">E</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="#groupId(java.lang.String)" class="member-name-link">groupId</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;groupId)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Sets the groupId value to assign to this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#groupSequence()" class="member-name-link">groupSequence</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="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="Message.html" title="type parameter in Message">E</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="#groupSequence(int)" class="member-name-link">groupSequence</a><wbr>(int&nbsp;groupSequence)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Sets the group sequence value to assign to this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#hasAnnotation(java.lang.String)" class="member-name-link">hasAnnotation</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;key)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Query the <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> to determine if it carries the given message annotation key.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#hasAnnotations()" class="member-name-link">hasAnnotations</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Query the <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> to determine if it carries any message annotations.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#hasFooter(java.lang.String)" class="member-name-link">hasFooter</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;key)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Query the <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> to determine if it carries the given footer key.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#hasFooters()" class="member-name-link">hasFooters</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Query the <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> to determine if it carries any footers.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#hasProperties()" class="member-name-link">hasProperties</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Query the <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> to determine if it carries any application properties.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#hasProperty(java.lang.String)" class="member-name-link">hasProperty</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;key)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Query the <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> to determine if it carries the given application property key.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#messageId()" class="member-name-link">messageId</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="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="Message.html" title="type parameter in Message">E</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="#messageId(java.lang.Object)" class="member-name-link">messageId</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>&nbsp;messageId)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Sets the message Id value to assign to this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>byte</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#priority()" class="member-name-link">priority</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="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="Message.html" title="type parameter in Message">E</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="#priority(byte)" class="member-name-link">priority</a><wbr>(byte&nbsp;priority)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Sets the relative message priority.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#property(java.lang.String)" class="member-name-link">property</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;key)</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 requested application property value from this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> if it exists
 or returns null otherwise.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="Message.html" title="type parameter in Message">E</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="#property(java.lang.String,java.lang.Object)" class="member-name-link">property</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;key,
 <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>&nbsp;value)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Sets the given application property value at the given key, replacing any previous value
 that was assigned to this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</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="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></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#removeAnnotation(java.lang.String)" class="member-name-link">removeAnnotation</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;key)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Removes the given message annotation from the values carried in the message currently, if none
 was present than this method returns <code>null</code>.</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/Object.html" title="class or interface in java.lang" class="external-link">Object</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#removeFooter(java.lang.String)" class="member-name-link">removeFooter</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;key)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Removes the given footer from the values carried in the message currently, if none
 was present than this method returns <code>null</code>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#removeProperty(java.lang.String)" class="member-name-link">removeProperty</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;key)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Removes the given application property from the values carried in the message currently, if none
 was present than this method returns <code>null</code>.</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="#replyTo()" class="member-name-link">replyTo</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="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="Message.html" title="type parameter in Message">E</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="#replyTo(java.lang.String)" class="member-name-link">replyTo</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;replyTo)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Sets the replyTo value to assign to this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/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="#replyToGroupId()" class="member-name-link">replyToGroupId</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="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="Message.html" title="type parameter in Message">E</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="#replyToGroupId(java.lang.String)" class="member-name-link">replyToGroupId</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;replyToGroupId)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Sets the replyTo group Id value to assign to this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/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="#subject()" class="member-name-link">subject</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="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="Message.html" title="type parameter in Message">E</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="#subject(java.lang.String)" class="member-name-link">subject</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;subject)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Sets the subject value to assign to this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>long</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#timeToLive()" class="member-name-link">timeToLive</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="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="Message.html" title="type parameter in Message">E</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="#timeToLive(long)" class="member-name-link">timeToLive</a><wbr>(long&nbsp;timeToLive)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Sets the message time to live value.</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="#to()" class="member-name-link">to</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="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="Message.html" title="type parameter in Message">E</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="#to(java.lang.String)" class="member-name-link">to</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;to)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Sets the 'to' value to assign to this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code>default <a href="AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client">AdvancedMessage</a>&lt;<a href="Message.html" title="type parameter in Message">E</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5"><code><a href="#toAdvancedMessage()" class="member-name-link">toAdvancedMessage</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab5">
<div class="block">Safely convert this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> instance into an <a href="AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client"><code>AdvancedMessage</code></a> reference
 which can offer more low level APIs to an experienced client user.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>byte[]</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#userId()" class="member-name-link">userId</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="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="Message.html" title="type parameter in Message">E</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="#userId(byte%5B%5D)" class="member-name-link">userId</a><wbr>(byte[]&nbsp;userId)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Sets the user Id value to assign to this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</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="create()">
<h3>create</h3>
<div class="member-signature"><span class="modifiers">static</span>&nbsp;<span class="type-parameters">&lt;E&gt;</span>&nbsp;<span class="return-type"><a href="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;E&gt;</span>&nbsp;<span class="element-name">create</span>()</div>
<div class="block">Create and return an <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> that will carry no body <a href="../types/messaging/Section.html" title="interface in org.apache.qpid.protonj2.types.messaging"><code>Section</code></a>
 unless one is assigned by the caller.</div>
<dl class="notes">
<dt>Type Parameters:</dt>
<dd><code>E</code> - The type that the message body should be treated as.</dd>
<dt>Returns:</dt>
<dd>a new <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> instance with an empty body <a href="../types/messaging/Section.html" title="interface in org.apache.qpid.protonj2.types.messaging"><code>Section</code></a>.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="create(E)">
<h3 id="create(java.lang.Object)">create</h3>
<div class="member-signature"><span class="modifiers">static</span>&nbsp;<span class="type-parameters">&lt;E&gt;</span>&nbsp;<span class="return-type"><a href="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;E&gt;</span>&nbsp;<span class="element-name">create</span><wbr><span class="parameters">(E&nbsp;body)</span></div>
<div class="block">Create and return an <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> that will wrap the given <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"><code>Object</code></a> in
 an <a href="../types/messaging/AmqpValue.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>AmqpValue</code></a> section.</div>
<dl class="notes">
<dt>Type Parameters:</dt>
<dd><code>E</code> - The type that the message body should be treated as.</dd>
<dt>Parameters:</dt>
<dd><code>body</code> - An object that will be wrapped in an <a href="../types/messaging/AmqpValue.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>AmqpValue</code></a> body section.</dd>
<dt>Returns:</dt>
<dd>a new <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> instance with a body containing the given value.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="create(byte[])">
<h3>create</h3>
<div class="member-signature"><span class="modifiers">static</span>&nbsp;<span class="return-type"><a href="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;byte[]&gt;</span>&nbsp;<span class="element-name">create</span><wbr><span class="parameters">(byte[]&nbsp;body)</span></div>
<div class="block">Create and return an <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> that will wrap the given byte array in
 an <a href="../types/messaging/Data.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>Data</code></a> section.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>body</code> - An byte array that will be wrapped in an <a href="../types/messaging/Data.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>Data</code></a> body section.</dd>
<dt>Returns:</dt>
<dd>a new <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> instance with a body containing the given byte array.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="create(java.util.List)">
<h3>create</h3>
<div class="member-signature"><span class="modifiers">static</span>&nbsp;<span class="type-parameters">&lt;E&gt;</span>&nbsp;<span class="return-type"><a href="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;&gt;</span>&nbsp;<span class="element-name">create</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;&nbsp;body)</span></div>
<div class="block">Create and return an <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> that will wrap the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link"><code>List</code></a> in
 an <a href="../types/messaging/AmqpSequence.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>AmqpSequence</code></a> section.</div>
<dl class="notes">
<dt>Type Parameters:</dt>
<dd><code>E</code> - The type that the List elements should be treated as.</dd>
<dt>Parameters:</dt>
<dd><code>body</code> - An List that will be wrapped in an <a href="../types/messaging/AmqpSequence.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>AmqpSequence</code></a> body section.</dd>
<dt>Returns:</dt>
<dd>a new <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> instance with a body containing the given List.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="create(java.util.Map)">
<h3>create</h3>
<div class="member-signature"><span class="modifiers">static</span>&nbsp;<span class="type-parameters">&lt;K,<wbr>
V&gt;</span>&nbsp;<span class="return-type"><a href="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<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;K,<wbr>V&gt;&gt;</span>&nbsp;<span class="element-name">create</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;K,<wbr>V&gt;&nbsp;body)</span></div>
<div class="block">Create and return an <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> that will wrap the given <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"><code>Map</code></a> in
 an <a href="../types/messaging/AmqpValue.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>AmqpValue</code></a> section.</div>
<dl class="notes">
<dt>Type Parameters:</dt>
<dd><code>K</code> - the type that the <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"><code>Map</code></a> keys should be treated as.</dd>
<dd><code>V</code> - the type that the <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"><code>Map</code></a> values should be treated as.</dd>
<dt>Parameters:</dt>
<dd><code>body</code> - An Map that will be wrapped in an <a href="../types/messaging/AmqpValue.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>AmqpValue</code></a> body section.</dd>
<dt>Returns:</dt>
<dd>a new <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> instance with a body containing the given Map.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="toAdvancedMessage()">
<h3>toAdvancedMessage</h3>
<div class="member-signature"><span class="modifiers">default</span>&nbsp;<span class="return-type"><a href="AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client">AdvancedMessage</a>&lt;<a href="Message.html" title="type parameter in Message">E</a>&gt;</span>&nbsp;<span class="element-name">toAdvancedMessage</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">Safely convert this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> instance into an <a href="AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client"><code>AdvancedMessage</code></a> reference
 which can offer more low level APIs to an experienced client user.
 <p>
 The default implementation first checks if the current instance is already of the correct
 type before performing a brute force conversion of the current message to the client's
 own internal <a href="AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client"><code>AdvancedMessage</code></a> implementation.  Users should override this method
 if the internal conversion implementation is insufficient to obtain the proper message
 structure to encode a meaningful 'on the wire' encoding of their custom implementation.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>a <a href="AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client"><code>AdvancedMessage</code></a> that contains this message's current state.</dd>
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/UnsupportedOperationException.html" title="class or interface in java.lang" class="external-link">UnsupportedOperationException</a></code> - if the <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> implementation cannot be converted</dd>
<dd><code><a href="exceptions/ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a></code> - if an error occurs while converting the message to an <a href="AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client"><code>AdvancedMessage</code></a>/</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="durable()">
<h3>durable</h3>
<div class="member-signature"><span class="return-type">boolean</span>&nbsp;<span class="element-name">durable</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">For an message being sent this method returns the current state of the
 durable flag on the message.  For a received message this method returns
 the durable flag value at the time of sending (or false if not set) unless
 the value is updated after being received by the receiver.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>true if the Message is marked as being durable</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 reading the given value.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="durable(boolean)">
<h3>durable</h3>
<div class="member-signature"><span class="return-type"><a href="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="Message.html" title="type parameter in Message">E</a>&gt;</span>&nbsp;<span class="element-name">durable</span><wbr><span class="parameters">(boolean&nbsp;durable)</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">Controls if the message is marked as durable when sent.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>durable</code> - value assigned to the durable flag for this message.</dd>
<dt>Returns:</dt>
<dd>this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</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 writing the given value.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="priority()">
<h3>priority</h3>
<div class="member-signature"><span class="return-type">byte</span>&nbsp;<span class="element-name">priority</span>()
       throws <span class="exceptions"><a href="exceptions/ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a></span></div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the currently configured priority or the default if none set.</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 reading the given value.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="priority(byte)">
<h3>priority</h3>
<div class="member-signature"><span class="return-type"><a href="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="Message.html" title="type parameter in Message">E</a>&gt;</span>&nbsp;<span class="element-name">priority</span><wbr><span class="parameters">(byte&nbsp;priority)</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">Sets the relative message priority.  Higher numbers indicate higher priority messages.
 Messages with higher priorities MAY be delivered before those with lower priorities.
 For a received message this overwrites any value that was set by the remote sender.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>priority</code> - The priority value to assign this message.</dd>
<dt>Returns:</dt>
<dd>this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</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 writing the given value.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="timeToLive()">
<h3>timeToLive</h3>
<div class="member-signature"><span class="return-type">long</span>&nbsp;<span class="element-name">timeToLive</span>()
         throws <span class="exceptions"><a href="exceptions/ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a></span></div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the currently set Time To Live duration (milliseconds).</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 reading the given value.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="timeToLive(long)">
<h3>timeToLive</h3>
<div class="member-signature"><span class="return-type"><a href="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="Message.html" title="type parameter in Message">E</a>&gt;</span>&nbsp;<span class="element-name">timeToLive</span><wbr><span class="parameters">(long&nbsp;timeToLive)</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">Sets the message time to live value.
 <p>
 The time to live duration in milliseconds for which the message is to be considered "live".
 If this is set then a message expiration time will be computed based on the time of arrival
 at an intermediary. Messages that live longer than their expiration time will be discarded
 (or dead lettered). When a message is transmitted by an intermediary that was received with a
 time to live, the transmitted message's header SHOULD contain a time to live that is computed
 as the difference between the current time and the formerly computed message expiration time,
 i.e., the reduced time to live, so that messages will eventually die if they end up in a
 delivery loop.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>timeToLive</code> - The time span in milliseconds that this message should remain live before being discarded.</dd>
<dt>Returns:</dt>
<dd>this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</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 writing the given value.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="firstAcquirer()">
<h3>firstAcquirer</h3>
<div class="member-signature"><span class="return-type">boolean</span>&nbsp;<span class="element-name">firstAcquirer</span>()
               throws <span class="exceptions"><a href="exceptions/ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a></span></div>
<dl class="notes">
<dt>Returns:</dt>
<dd>if this message has been acquired by another link previously</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 reading the given value.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="firstAcquirer(boolean)">
<h3>firstAcquirer</h3>
<div class="member-signature"><span class="return-type"><a href="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="Message.html" title="type parameter in Message">E</a>&gt;</span>&nbsp;<span class="element-name">firstAcquirer</span><wbr><span class="parameters">(boolean&nbsp;firstAcquirer)</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">Sets the value to assign to the first acquirer field of this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.
 <p>
 If this value is true, then this message has not been acquired by any other link.  If this
 value is false, then this message MAY have previously been acquired by another link or links.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>firstAcquirer</code> - The boolean value to assign to the first acquirer field of the message.</dd>
<dt>Returns:</dt>
<dd>this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</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 writing the given value.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="deliveryCount()">
<h3>deliveryCount</h3>
<div class="member-signature"><span class="return-type">long</span>&nbsp;<span class="element-name">deliveryCount</span>()
            throws <span class="exceptions"><a href="exceptions/ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a></span></div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the number of failed delivery attempts that this message has been part of.</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 reading the given value.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="deliveryCount(long)">
<h3>deliveryCount</h3>
<div class="member-signature"><span class="return-type"><a href="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="Message.html" title="type parameter in Message">E</a>&gt;</span>&nbsp;<span class="element-name">deliveryCount</span><wbr><span class="parameters">(long&nbsp;deliveryCount)</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">Sets the value to assign to the delivery count field of this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.
 <p>
 Delivery count is the number of unsuccessful previous attempts to deliver this message.
 If this value is non-zero it can be taken as an indication that the delivery might be a
 duplicate. On first delivery, the value is zero. It is incremented upon an outcome being
 settled at the sender, according to rules defined for each outcome.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>deliveryCount</code> - The new delivery count value to assign to this message.</dd>
<dt>Returns:</dt>
<dd>this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</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 writing the given value.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="messageId()">
<h3>messageId</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/Object.html" title="class or interface in java.lang" class="external-link">Object</a></span>&nbsp;<span class="element-name">messageId</span>()
          throws <span class="exceptions"><a href="exceptions/ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a></span></div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the currently set Message ID or null if none set.</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 reading the given value.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="messageId(java.lang.Object)">
<h3>messageId</h3>
<div class="member-signature"><span class="return-type"><a href="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="Message.html" title="type parameter in Message">E</a>&gt;</span>&nbsp;<span class="element-name">messageId</span><wbr><span class="parameters">(<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>&nbsp;messageId)</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">Sets the message Id value to assign to this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.
 <p>
 The message Id, if set, uniquely identifies a message within the message system. The message
 producer is usually responsible for setting the message-id in such a way that it is assured to
 be globally unique. A remote peer MAY discard a message as a duplicate if the value of the
 message-id matches that of a previously received message sent to the same node.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>messageId</code> - The message Id value to assign to this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> instance.</dd>
<dt>Returns:</dt>
<dd>this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</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 writing the given value.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="userId()">
<h3>userId</h3>
<div class="member-signature"><span class="return-type">byte[]</span>&nbsp;<span class="element-name">userId</span>()
       throws <span class="exceptions"><a href="exceptions/ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a></span></div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the currently set User ID or null if none set.</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 reading the given value.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="userId(byte[])">
<h3>userId</h3>
<div class="member-signature"><span class="return-type"><a href="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="Message.html" title="type parameter in Message">E</a>&gt;</span>&nbsp;<span class="element-name">userId</span><wbr><span class="parameters">(byte[]&nbsp;userId)</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">Sets the user Id value to assign to this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.
 <p>
 The identity of the user responsible for producing the message. The client sets this value,
 and it MAY be authenticated by intermediaries.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>userId</code> - The user Id value to assign to this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> instance.</dd>
<dt>Returns:</dt>
<dd>this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</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 writing the given value.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="to()">
<h3>to</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">to</span>()
   throws <span class="exceptions"><a href="exceptions/ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a></span></div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the currently set 'To' address which indicates the intended destination of the message.</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 reading the given value.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="to(java.lang.String)">
<h3>to</h3>
<div class="member-signature"><span class="return-type"><a href="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="Message.html" title="type parameter in Message">E</a>&gt;</span>&nbsp;<span class="element-name">to</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;to)</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">Sets the 'to' value to assign to this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.
 <p>
 The to field identifies the node that is the intended destination of the message. On any given
 transfer this might not be the node at the receiving end of the link.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>to</code> - The 'to' node value to assign to this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> instance.</dd>
<dt>Returns:</dt>
<dd>this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</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 writing the given value.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="subject()">
<h3>subject</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">subject</span>()
        throws <span class="exceptions"><a href="exceptions/ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a></span></div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the currently set subject metadata for this message or null if none set.</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 reading the given value.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="subject(java.lang.String)">
<h3>subject</h3>
<div class="member-signature"><span class="return-type"><a href="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="Message.html" title="type parameter in Message">E</a>&gt;</span>&nbsp;<span class="element-name">subject</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;subject)</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">Sets the subject value to assign to this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.
 <p>
 A common field for summary information about the message content and purpose.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>subject</code> - The subject node value to assign to this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> instance.</dd>
<dt>Returns:</dt>
<dd>this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</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 writing the given value.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="replyTo()">
<h3>replyTo</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">replyTo</span>()
        throws <span class="exceptions"><a href="exceptions/ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a></span></div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the configured address of the node where replies to this message should be sent, or null if not set.</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 reading the given value.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="replyTo(java.lang.String)">
<h3>replyTo</h3>
<div class="member-signature"><span class="return-type"><a href="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="Message.html" title="type parameter in Message">E</a>&gt;</span>&nbsp;<span class="element-name">replyTo</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;replyTo)</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">Sets the replyTo value to assign to this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.
 <p>
 The address of the node to send replies to.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>replyTo</code> - The replyTo node value to assign to this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> instance.</dd>
<dt>Returns:</dt>
<dd>this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</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 writing the given value.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="correlationId()">
<h3>correlationId</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/Object.html" title="class or interface in java.lang" class="external-link">Object</a></span>&nbsp;<span class="element-name">correlationId</span>()
              throws <span class="exceptions"><a href="exceptions/ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a></span></div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the currently assigned correlation ID or null if none set.</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 reading the given value.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="correlationId(java.lang.Object)">
<h3>correlationId</h3>
<div class="member-signature"><span class="return-type"><a href="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="Message.html" title="type parameter in Message">E</a>&gt;</span>&nbsp;<span class="element-name">correlationId</span><wbr><span class="parameters">(<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>&nbsp;correlationId)</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">Sets the correlationId value to assign to this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.
 <p>
 This is a client-specific id that can be used to mark or identify messages between clients.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>correlationId</code> - The correlationId value to assign to this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> instance.</dd>
<dt>Returns:</dt>
<dd>this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</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 writing the given value.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="contentType()">
<h3>contentType</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">contentType</span>()
            throws <span class="exceptions"><a href="exceptions/ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a></span></div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the assigned content type value for the message body section or null if not set.</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 reading the given value.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="contentType(java.lang.String)">
<h3>contentType</h3>
<div class="member-signature"><span class="return-type"><a href="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="Message.html" title="type parameter in Message">E</a>&gt;</span>&nbsp;<span class="element-name">contentType</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;contentType)</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">Sets the contentType value to assign to this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.
 <p>
 The RFC-2046 MIME type for the message's application-data section (body). As per RFC-2046 this can
 contain a charset parameter defining the character encoding used: e.g., 'text/plain; charset="utf-8"'.
 <p>
 For clarity, as per section 7.2.1 of RFC-2616, where the content type is unknown the content-type
 SHOULD NOT be set. This allows the recipient the opportunity to determine the actual type. Where the
 section is known to be truly opaque binary data, the content-type SHOULD be set to application/octet-stream.
 <p>
 When using an application-data section with a section code other than data, content-type SHOULD NOT be set.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>contentType</code> - The contentType value to assign to this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> instance.</dd>
<dt>Returns:</dt>
<dd>this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</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 writing the given value.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="contentEncoding()">
<h3>contentEncoding</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">contentEncoding</span>()
                throws <span class="exceptions"><a href="exceptions/ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a></span></div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the assigned content encoding value for the message body section or null if not set.</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 reading the given value.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="contentEncoding(java.lang.String)">
<h3>contentEncoding</h3>
<div class="member-signature"><span class="return-type"><a href="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;?&gt;</span>&nbsp;<span class="element-name">contentEncoding</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;contentEncoding)</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">Sets the contentEncoding value to assign to this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.
 <p>
 The content-encoding property is used as a modifier to the content-type. When present, its value
 indicates what additional content encodings have been applied to the application-data, and thus what
 decoding mechanisms need to be applied in order to obtain the media-type referenced by the content-type
 header field.
 <p>
 Content-encoding is primarily used to allow a document to be compressed without losing the identity of
 its underlying content type.
 <p>
 Content-encodings are to be interpreted as per section 3.5 of RFC 2616 [RFC2616]. Valid content-encodings
 are registered at IANA [IANAHTTPPARAMS].
 <p>
 The content-encoding MUST NOT be set when the application-data section is other than data. The binary
 representation of all other application-data section types is defined completely in terms of the AMQP
 type system.
 <p>
 Implementations MUST NOT use the identity encoding. Instead, implementations SHOULD NOT set this property.
 Implementations SHOULD NOT use the compress encoding, except as to remain compatible with messages originally
 sent with other protocols, e.g. HTTP or SMTP.
 <p>
 Implementations SHOULD NOT specify multiple content-encoding values except as to be compatible with messages
 originally sent with other protocols, e.g. HTTP or SMTP.
 <p></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>contentEncoding</code> - The contentEncoding value to assign to this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> instance.</dd>
<dt>Returns:</dt>
<dd>this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</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 writing the given value.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="absoluteExpiryTime()">
<h3>absoluteExpiryTime</h3>
<div class="member-signature"><span class="return-type">long</span>&nbsp;<span class="element-name">absoluteExpiryTime</span>()
                 throws <span class="exceptions"><a href="exceptions/ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a></span></div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the configured absolute time of expiration for this message.</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 reading the given value.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="absoluteExpiryTime(long)">
<h3>absoluteExpiryTime</h3>
<div class="member-signature"><span class="return-type"><a href="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="Message.html" title="type parameter in Message">E</a>&gt;</span>&nbsp;<span class="element-name">absoluteExpiryTime</span><wbr><span class="parameters">(long&nbsp;expiryTime)</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">Sets the absolute expiration time value to assign to this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.
 <p>
 An absolute time when this message is considered to be expired.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>expiryTime</code> - The absolute expiration time value to assign to this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> instance.</dd>
<dt>Returns:</dt>
<dd>this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</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 writing the given value.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="creationTime()">
<h3>creationTime</h3>
<div class="member-signature"><span class="return-type">long</span>&nbsp;<span class="element-name">creationTime</span>()
           throws <span class="exceptions"><a href="exceptions/ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a></span></div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the absolute time of creation for this message.</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 reading the given value.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="creationTime(long)">
<h3>creationTime</h3>
<div class="member-signature"><span class="return-type"><a href="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="Message.html" title="type parameter in Message">E</a>&gt;</span>&nbsp;<span class="element-name">creationTime</span><wbr><span class="parameters">(long&nbsp;createTime)</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">Sets the creation time value to assign to this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.
 <p>
 An absolute time when this message was created.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>createTime</code> - The creation time value to assign to this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> instance.</dd>
<dt>Returns:</dt>
<dd>this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</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 writing the given value.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="groupId()">
<h3>groupId</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">groupId</span>()
        throws <span class="exceptions"><a href="exceptions/ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a></span></div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the assigned group ID for this message or null if not set.</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 reading the given value.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="groupId(java.lang.String)">
<h3>groupId</h3>
<div class="member-signature"><span class="return-type"><a href="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="Message.html" title="type parameter in Message">E</a>&gt;</span>&nbsp;<span class="element-name">groupId</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;groupId)</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">Sets the groupId value to assign to this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.
 <p>
 Identifies the group the message belongs to.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>groupId</code> - The groupId value to assign to this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> instance.</dd>
<dt>Returns:</dt>
<dd>this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</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 writing the given value.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="groupSequence()">
<h3>groupSequence</h3>
<div class="member-signature"><span class="return-type">int</span>&nbsp;<span class="element-name">groupSequence</span>()
           throws <span class="exceptions"><a href="exceptions/ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a></span></div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the assigned group sequence for this message.</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 reading the given value.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="groupSequence(int)">
<h3>groupSequence</h3>
<div class="member-signature"><span class="return-type"><a href="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="Message.html" title="type parameter in Message">E</a>&gt;</span>&nbsp;<span class="element-name">groupSequence</span><wbr><span class="parameters">(int&nbsp;groupSequence)</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">Sets the group sequence value to assign to this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.
 <p>
 The relative position of this message within its group.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>groupSequence</code> - The group sequence to assign to this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> instance.</dd>
<dt>Returns:</dt>
<dd>this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</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 writing the given value.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="replyToGroupId()">
<h3>replyToGroupId</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">replyToGroupId</span>()
               throws <span class="exceptions"><a href="exceptions/ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a></span></div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the client-specific id used so that client can send replies to this message to a specific group.</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 reading the given value.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="replyToGroupId(java.lang.String)">
<h3>replyToGroupId</h3>
<div class="member-signature"><span class="return-type"><a href="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="Message.html" title="type parameter in Message">E</a>&gt;</span>&nbsp;<span class="element-name">replyToGroupId</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;replyToGroupId)</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">Sets the replyTo group Id value to assign to this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.
 <p>
 This is a client-specific id that is used so that client can send replies to this message
 to a specific group.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>replyToGroupId</code> - The replyTo group Id to assign to this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> instance.</dd>
<dt>Returns:</dt>
<dd>this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</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 writing the given value.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="annotation(java.lang.String)">
<h3>annotation</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/Object.html" title="class or interface in java.lang" class="external-link">Object</a></span>&nbsp;<span class="element-name">annotation</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;key)</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 requested message annotation value from this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> if it exists
 or returns null otherwise.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>key</code> - The key of the message annotation to query for.</dd>
<dt>Returns:</dt>
<dd>the corresponding message annotation value of null if none was carried in this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</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 error occurs accessing the message annotations in this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="hasAnnotation(java.lang.String)">
<h3>hasAnnotation</h3>
<div class="member-signature"><span class="return-type">boolean</span>&nbsp;<span class="element-name">hasAnnotation</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;key)</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">Query the <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> to determine if it carries the given message annotation key.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>key</code> - The key of the message annotation to query for.</dd>
<dt>Returns:</dt>
<dd><code>true</code> if the Message carries the given message annotation.</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 accessing the message annotations in this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="hasAnnotations()">
<h3>hasAnnotations</h3>
<div class="member-signature"><span class="return-type">boolean</span>&nbsp;<span class="element-name">hasAnnotations</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">Query the <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> to determine if it carries any message annotations.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd><code>true</code> if the Message carries any message annotations.</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 accessing the message annotations in this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="removeAnnotation(java.lang.String)">
<h3>removeAnnotation</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/Object.html" title="class or interface in java.lang" class="external-link">Object</a></span>&nbsp;<span class="element-name">removeAnnotation</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;key)</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">Removes the given message annotation from the values carried in the message currently, if none
 was present than this method returns <code>null</code>.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>key</code> - The key of the message annotation to query for removal.</dd>
<dt>Returns:</dt>
<dd>the message annotation value that was previously assigned to that key.</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 accessing the message annotations in this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="forEachAnnotation(java.util.function.BiConsumer)">
<h3>forEachAnnotation</h3>
<div class="member-signature"><span class="return-type"><a href="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="Message.html" title="type parameter in Message">E</a>&gt;</span>&nbsp;<span class="element-name">forEachAnnotation</span><wbr><span class="parameters">(<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="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;action)</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">Invokes the given <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"><code>BiConsumer</code></a> on each message annotation entry carried in this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>action</code> - The action that will be invoked on each message annotation entry.</dd>
<dt>Returns:</dt>
<dd>this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</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 accessing the message annotations in this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="annotation(java.lang.String,java.lang.Object)">
<h3>annotation</h3>
<div class="member-signature"><span class="return-type"><a href="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="Message.html" title="type parameter in Message">E</a>&gt;</span>&nbsp;<span class="element-name">annotation</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;key,
 <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>&nbsp;value)</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">Sets the given message annotation value at the given key, replacing any previous value
 that was assigned to this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>key</code> - The message annotation key where the value is to be assigned.</dd>
<dd><code>value</code> - The value to assign to the given message annotation key.</dd>
<dt>Returns:</dt>
<dd>this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</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 accessing the message annotations in this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="property(java.lang.String)">
<h3>property</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/Object.html" title="class or interface in java.lang" class="external-link">Object</a></span>&nbsp;<span class="element-name">property</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;key)</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 requested application property value from this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> if it exists
 or returns null otherwise.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>key</code> - The key of the application property to query for.</dd>
<dt>Returns:</dt>
<dd>the corresponding application property value of null if none was carried in this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</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 error occurs accessing the application properties in this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="property(java.lang.String,java.lang.Object)">
<h3>property</h3>
<div class="member-signature"><span class="return-type"><a href="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="Message.html" title="type parameter in Message">E</a>&gt;</span>&nbsp;<span class="element-name">property</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;key,
 <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>&nbsp;value)</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">Sets the given application property value at the given key, replacing any previous value
 that was assigned to this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>key</code> - The application property key where the value is to be assigned.</dd>
<dd><code>value</code> - The value to assign to the given application property key.</dd>
<dt>Returns:</dt>
<dd>this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</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 accessing the application properties in this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="hasProperty(java.lang.String)">
<h3>hasProperty</h3>
<div class="member-signature"><span class="return-type">boolean</span>&nbsp;<span class="element-name">hasProperty</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;key)</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">Query the <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> to determine if it carries the given application property key.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>key</code> - The key of the application property to query for.</dd>
<dt>Returns:</dt>
<dd><code>true</code> if the Message carries the given application property.</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 accessing the application properties in this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="hasProperties()">
<h3>hasProperties</h3>
<div class="member-signature"><span class="return-type">boolean</span>&nbsp;<span class="element-name">hasProperties</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">Query the <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> to determine if it carries any application properties.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd><code>true</code> if the Message carries any application properties.</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 accessing the application properties in this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="removeProperty(java.lang.String)">
<h3>removeProperty</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/Object.html" title="class or interface in java.lang" class="external-link">Object</a></span>&nbsp;<span class="element-name">removeProperty</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;key)</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">Removes the given application property from the values carried in the message currently, if none
 was present than this method returns <code>null</code>.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>key</code> - The key of the application property to query for removal.</dd>
<dt>Returns:</dt>
<dd>the application property value that was previously assigned to that key.</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 accessing the application properties in this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="forEachProperty(java.util.function.BiConsumer)">
<h3>forEachProperty</h3>
<div class="member-signature"><span class="return-type"><a href="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="Message.html" title="type parameter in Message">E</a>&gt;</span>&nbsp;<span class="element-name">forEachProperty</span><wbr><span class="parameters">(<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="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;action)</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">Invokes the given <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"><code>BiConsumer</code></a> on each application property entry carried in this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>action</code> - The action that will be invoked on each application property entry.</dd>
<dt>Returns:</dt>
<dd>this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</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 accessing the application properties in this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="footer(java.lang.String)">
<h3>footer</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/Object.html" title="class or interface in java.lang" class="external-link">Object</a></span>&nbsp;<span class="element-name">footer</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;key)</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 requested footer value from this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> if it exists or returns
 <code>null</code> otherwise.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>key</code> - The key of the footer to query for.</dd>
<dt>Returns:</dt>
<dd>the corresponding footer value of null if none was carried in this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</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 error occurs accessing the footers in this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="hasFooter(java.lang.String)">
<h3>hasFooter</h3>
<div class="member-signature"><span class="return-type">boolean</span>&nbsp;<span class="element-name">hasFooter</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;key)</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">Query the <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> to determine if it carries the given footer key.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>key</code> - The key of the footer to query for.</dd>
<dt>Returns:</dt>
<dd><code>true</code> if the Message carries the given footer.</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 accessing the footers in this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="hasFooters()">
<h3>hasFooters</h3>
<div class="member-signature"><span class="return-type">boolean</span>&nbsp;<span class="element-name">hasFooters</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">Query the <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> to determine if it carries any footers.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd><code>true</code> if the Message carries any footers.</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 accessing the footers in this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="removeFooter(java.lang.String)">
<h3>removeFooter</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/Object.html" title="class or interface in java.lang" class="external-link">Object</a></span>&nbsp;<span class="element-name">removeFooter</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;key)</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">Removes the given footer from the values carried in the message currently, if none
 was present than this method returns <code>null</code>.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>key</code> - The key of the footer to query for removal.</dd>
<dt>Returns:</dt>
<dd>the footer value that was previously assigned to that key.</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 accessing the footers in this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="forEachFooter(java.util.function.BiConsumer)">
<h3>forEachFooter</h3>
<div class="member-signature"><span class="return-type"><a href="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="Message.html" title="type parameter in Message">E</a>&gt;</span>&nbsp;<span class="element-name">forEachFooter</span><wbr><span class="parameters">(<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="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;action)</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">Invokes the given <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"><code>BiConsumer</code></a> on each footer entry carried in this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>action</code> - The action that will be invoked on each footer entry.</dd>
<dt>Returns:</dt>
<dd>this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</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 accessing the footers in this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="footer(java.lang.String,java.lang.Object)">
<h3>footer</h3>
<div class="member-signature"><span class="return-type"><a href="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="Message.html" title="type parameter in Message">E</a>&gt;</span>&nbsp;<span class="element-name">footer</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;key,
 <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>&nbsp;value)</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">Sets the given footer value at the given key, replacing any previous value
 that was assigned to this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>key</code> - The footer key where the value is to be assigned.</dd>
<dd><code>value</code> - The value to assign to the given footer key.</dd>
<dt>Returns:</dt>
<dd>this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</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 accessing the footers in this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="body()">
<h3>body</h3>
<div class="member-signature"><span class="return-type"><a href="Message.html" title="type parameter in Message">E</a></span>&nbsp;<span class="element-name">body</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 body value that is conveyed in this message or null if no body was set locally
 or sent from the remote if this is an incoming message.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the message body value or null if none present.</dd>
<dt>Throws:</dt>
<dd><code><a href="exceptions/ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a></code> - if the implementation can't provide a body for some reason.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="body(E)">
<h3 id="body(java.lang.Object)">body</h3>
<div class="member-signature"><span class="return-type"><a href="Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="Message.html" title="type parameter in Message">E</a>&gt;</span>&nbsp;<span class="element-name">body</span><wbr><span class="parameters">(<a href="Message.html" title="type parameter in Message">E</a>&nbsp;value)</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">Sets the body value that is to be conveyed to the remote when this message is sent.
 <p>
 The <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> implementation will choose the AMQP <a href="../types/messaging/Section.html" title="interface in org.apache.qpid.protonj2.types.messaging"><code>Section</code></a> to use to wrap
 the given value.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>value</code> - The value to assign to the given message body <a href="../types/messaging/Section.html" title="interface in org.apache.qpid.protonj2.types.messaging"><code>Section</code></a>.</dd>
<dt>Returns:</dt>
<dd>this <a href="Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</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 the implementation cannot write to the body section for some reason..</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; 2024 <a href="https://www.apache.org/">The Apache Software Foundation</a>. All rights reserved.</small></p>
</footer>
</div>
</div>
</body>
</html>
