<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>ClientMessage (Qpid ProtonJ2 Parent 1.0.0-M18 API)</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<meta name="description" content="declaration: package: org.apache.qpid.protonj2.client.impl, class: ClientMessage">
<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/ClientMessage.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.impl</a></div>
<h1 title="Class ClientMessage" class="title">Class ClientMessage&lt;E&gt;</h1>
</div>
<div class="inheritance" title="Inheritance Tree"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">java.lang.Object</a>
<div class="inheritance">org.apache.qpid.protonj2.client.impl.ClientMessage&lt;E&gt;</div>
</div>
<section class="class-description" id="class-description">
<dl class="notes">
<dt>Type Parameters:</dt>
<dd><code>E</code> - the body type that the <a href="../Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> carries</dd>
</dl>
<dl class="notes">
<dt>All Implemented Interfaces:</dt>
<dd><code><a href="../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client">AdvancedMessage</a>&lt;E&gt;</code>, <code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;E&gt;</code></dd>
</dl>
<hr>
<div class="type-signature"><span class="modifiers">public final class </span><span class="element-name type-name-label">ClientMessage&lt;E&gt;</span>
<span class="extends-implements">extends <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>
implements <a href="../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client">AdvancedMessage</a>&lt;E&gt;</span></div>
<div class="block">Client provided <a href="../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client"><code>AdvancedMessage</code></a> implementation that is used when sending messages
 from a <a href="ClientSender.html" title="class in org.apache.qpid.protonj2.client.impl"><code>ClientSender</code></a> or when decoding an AMQP Transfer for which all frames have
 arrived.</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-tab4" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab4', 3)" class="table-tab">Concrete Methods</button></div>
<div id="method-summary-table.tabpanel" role="tabpanel">
<div class="summary-table three-column-summary" aria-labelledby="method-summary-table-tab0">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Method</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>long</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#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-tab4">
<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-tab4"><code><a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl">ClientMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#addBodySection(org.apache.qpid.protonj2.types.messaging.Section)" class="member-name-link">addBodySection</a><wbr>(<a href="../../types/messaging/Section.html" title="interface in org.apache.qpid.protonj2.types.messaging">Section</a>&lt;?&gt;&nbsp;bodySection)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Adds the given <a href="../../types/messaging/Section.html" title="interface in org.apache.qpid.protonj2.types.messaging"><code>Section</code></a> to the internal collection of sections that will be sent
 to the remote peer when this message is encoded.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/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-tab4"><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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl">ClientMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../../types/messaging/MessageAnnotations.html" title="class in org.apache.qpid.protonj2.types.messaging">MessageAnnotations</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#annotations()" class="member-name-link">annotations</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Return the current <a href="../../types/messaging/MessageAnnotations.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>MessageAnnotations</code></a> assigned to this message, if none was assigned yet
 then 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-tab4"><code><a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl">ClientMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#annotations(org.apache.qpid.protonj2.types.messaging.MessageAnnotations)" class="member-name-link">annotations</a><wbr>(<a href="../../types/messaging/MessageAnnotations.html" title="class in org.apache.qpid.protonj2.types.messaging">MessageAnnotations</a>&nbsp;messageAnnotations)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Assign or replace the <a href="../../types/messaging/MessageAnnotations.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>MessageAnnotations</code></a> instance associated with this message.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../../types/messaging/ApplicationProperties.html" title="class in org.apache.qpid.protonj2.types.messaging">ApplicationProperties</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#applicationProperties()" class="member-name-link">applicationProperties</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Return the current <a href="../../types/messaging/ApplicationProperties.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>ApplicationProperties</code></a> assigned to this message, if none was assigned yet
 then 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-tab4"><code><a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl">ClientMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#applicationProperties(org.apache.qpid.protonj2.types.messaging.ApplicationProperties)" class="member-name-link">applicationProperties</a><wbr>(<a href="../../types/messaging/ApplicationProperties.html" title="class in org.apache.qpid.protonj2.types.messaging">ApplicationProperties</a>&nbsp;applicationProperties)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Assign or replace the <a href="../../types/messaging/ApplicationProperties.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>ApplicationProperties</code></a> instance associated with this message.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ClientMessage.html" title="type parameter in ClientMessage">E</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#body()" class="member-name-link">body</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns the 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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl">ClientMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#body(E)" class="member-name-link">body</a><wbr>(<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&nbsp;value)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;<a href="../../types/messaging/Section.html" title="interface in org.apache.qpid.protonj2.types.messaging">Section</a>&lt;?&gt;&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#bodySections()" class="member-name-link">bodySections</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Create and return an unmodifiable <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link"><code>Collection</code></a> that contains the <a href="../../types/messaging/Section.html" title="interface in org.apache.qpid.protonj2.types.messaging"><code>Section</code></a> instances
 currently assigned to this message.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl">ClientMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#bodySections(java.util.Collection)" class="member-name-link">bodySections</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;<a href="../../types/messaging/Section.html" title="interface in org.apache.qpid.protonj2.types.messaging">Section</a>&lt;?&gt;&gt;&nbsp;sections)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets the body <a href="../../types/messaging/Section.html" title="interface in org.apache.qpid.protonj2.types.messaging"><code>Section</code></a> instances to use when encoding this message.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl">ClientMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#clearBodySections()" class="member-name-link">clearBodySections</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Clears all current body <a href="../../types/messaging/Section.html" title="interface in org.apache.qpid.protonj2.types.messaging"><code>Section</code></a> elements from the <a href="../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client"><code>AdvancedMessage</code></a>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#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-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#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-tab4">
<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-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#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-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#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-tab4">
<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-tab4"><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-tab4"><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-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#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-tab4">
<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 method-summary-table-tab4"><code>static &lt;V&gt;&nbsp;<a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl">ClientMessage</a>&lt;V&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><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 method-summary-table-tab4">
<div class="block">Creates an empty <a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl"><code>ClientMessage</code></a> instance.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;V&gt;&nbsp;<a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl">ClientMessage</a>&lt;V&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#create(org.apache.qpid.protonj2.types.messaging.Section)" class="member-name-link">create</a><wbr>(<a href="../../types/messaging/Section.html" title="interface in org.apache.qpid.protonj2.types.messaging">Section</a>&lt;V&gt;&nbsp;body)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates an <a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl"><code>ClientMessage</code></a> instance with the given body <a href="../../types/messaging/Section.html" title="interface in org.apache.qpid.protonj2.types.messaging"><code>Section</code></a> value.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;V&gt;&nbsp;<a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl">ClientMessage</a>&lt;V&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#createAdvancedMessage()" class="member-name-link">createAdvancedMessage</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates an empty <a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl"><code>ClientMessage</code></a> instance.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>long</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#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-tab4">
<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-tab4"><code>long</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl">ClientMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#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-tab4">
<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-tab4"><code>boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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-tab4">
<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-tab4"><code><a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl">ClientMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#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-tab4">
<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-tab4"><code><a href="../../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#encode(java.util.Map,org.apache.qpid.protonj2.buffer.ProtonBufferAllocator)" class="member-name-link">encode</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;deliveryAnnotations,
 <a href="../../buffer/ProtonBufferAllocator.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferAllocator</a>&nbsp;allocator)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Encodes the <a href="../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client"><code>AdvancedMessage</code></a> for transmission by the client.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#firstAcquirer()" class="member-name-link">firstAcquirer</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl">ClientMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#firstAcquirer(boolean)" class="member-name-link">firstAcquirer</a><wbr>(boolean&nbsp;firstAcquirer)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../../types/messaging/Footer.html" title="class in org.apache.qpid.protonj2.types.messaging">Footer</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#footer()" class="member-name-link">footer</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Return the current <a href="../../types/messaging/Footer.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>Footer</code></a> assigned to this message, if none was assigned yet
 then 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-tab4"><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-tab4"><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-tab4">
<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-tab4"><code><a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl">ClientMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#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-tab4">
<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-tab4"><code><a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl">ClientMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#footer(org.apache.qpid.protonj2.types.messaging.Footer)" class="member-name-link">footer</a><wbr>(<a href="../../types/messaging/Footer.html" title="class in org.apache.qpid.protonj2.types.messaging">Footer</a>&nbsp;footer)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Assign or replace the <a href="../../types/messaging/Footer.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>Footer</code></a> instance associated with this message.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl">ClientMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#forEachBodySection(java.util.function.Consumer)" class="member-name-link">forEachBodySection</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/function/Consumer.html" title="class or interface in java.util.function" class="external-link">Consumer</a>&lt;<a href="../../types/messaging/Section.html" title="interface in org.apache.qpid.protonj2.types.messaging">Section</a>&lt;?&gt;&gt;&nbsp;consumer)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Performs the given action for each body <a href="../../types/messaging/Section.html" title="interface in org.apache.qpid.protonj2.types.messaging"><code>Section</code></a> of the <a href="../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client"><code>AdvancedMessage</code></a> until all
 sections have been presented to the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/function/Consumer.html" title="class or interface in java.util.function" class="external-link"><code>Consumer</code></a> or the consumer throws an exception.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#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-tab4">
<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-tab4"><code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#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-tab4">
<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-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#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-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#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-tab4">
<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-tab4"><code>int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#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-tab4">
<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-tab4"><code>boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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-tab4">
<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-tab4"><code>boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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-tab4">
<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-tab4"><code>boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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-tab4">
<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-tab4"><code>boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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-tab4">
<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-tab4"><code>boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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-tab4">
<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-tab4"><code>boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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-tab4">
<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-tab4"><code><a href="../../types/messaging/Header.html" title="class in org.apache.qpid.protonj2.types.messaging">Header</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#header()" class="member-name-link">header</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Return the current <a href="../../types/messaging/Header.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>Header</code></a> assigned to this message, if none was assigned yet
 then 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-tab4"><code><a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl">ClientMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#header(org.apache.qpid.protonj2.types.messaging.Header)" class="member-name-link">header</a><wbr>(<a href="../../types/messaging/Header.html" title="class in org.apache.qpid.protonj2.types.messaging">Header</a>&nbsp;header)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Assign or replace the <a href="../../types/messaging/Header.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>Header</code></a> instance associated with this message.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#messageFormat()" class="member-name-link">messageFormat</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl">ClientMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#messageFormat(int)" class="member-name-link">messageFormat</a><wbr>(int&nbsp;messageFormat)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets the message format to use when the message is sent.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/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-tab4"><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-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#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-tab4">
<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-tab4"><code>byte</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl">ClientMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#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-tab4">
<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-tab4"><code><a href="../../types/messaging/Properties.html" title="class in org.apache.qpid.protonj2.types.messaging">Properties</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#properties()" class="member-name-link">properties</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Return the current <a href="../../types/messaging/Properties.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>Properties</code></a> assigned to this message, if none was assigned yet
 then 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-tab4"><code><a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl">ClientMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#properties(org.apache.qpid.protonj2.types.messaging.Properties)" class="member-name-link">properties</a><wbr>(<a href="../../types/messaging/Properties.html" title="class in org.apache.qpid.protonj2.types.messaging">Properties</a>&nbsp;properties)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Assign or replace the <a href="../../types/messaging/Properties.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>Properties</code></a> instance associated with this message.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/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-tab4"><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-tab4">
<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-tab4"><code><a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl">ClientMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#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-tab4">
<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-tab4"><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-tab4"><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-tab4">
<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-tab4"><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-tab4"><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-tab4">
<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-tab4"><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-tab4"><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-tab4">
<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-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#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-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#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-tab4">
<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-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#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-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#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-tab4">
<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-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#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-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#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-tab4">
<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-tab4"><code>long</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl">ClientMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#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-tab4">
<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-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#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-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#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-tab4">
<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-tab4"><code><a href="../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client">AdvancedMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#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-tab4">
<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-tab4"><code>byte[]</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#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-tab4">
<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>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-java.lang.Object">Methods inherited from class&nbsp;java.lang.<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></h3>
<code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#clone()" title="class or interface in java.lang" class="external-link">clone</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#equals(java.lang.Object)" title="class or interface in java.lang" class="external-link">equals</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#finalize()" title="class or interface in java.lang" class="external-link">finalize</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#getClass()" title="class or interface in java.lang" class="external-link">getClass</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#hashCode()" title="class or interface in java.lang" class="external-link">hashCode</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#notify()" title="class or interface in java.lang" class="external-link">notify</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#notifyAll()" title="class or interface in java.lang" class="external-link">notifyAll</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#toString()" title="class or interface in java.lang" class="external-link">toString</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#wait()" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#wait(long)" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#wait(long,int)" title="class or interface in java.lang" class="external-link">wait</a></code></div>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-org.apache.qpid.protonj2.client.AdvancedMessage">Methods inherited from interface&nbsp;org.apache.qpid.protonj2.client.<a href="../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client">AdvancedMessage</a></h3>
<code><a href="../AdvancedMessage.html#encode(java.util.Map)">encode</a></code></div>
</section>
</li>
</ul>
</section>
<section class="details">
<ul class="details-list">
<!-- ============ METHOD DETAIL ========== -->
<li>
<section class="method-details" id="method-detail">
<h2>Method Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="toAdvancedMessage()">
<h3>toAdvancedMessage</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client">AdvancedMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</span>&nbsp;<span class="element-name">toAdvancedMessage</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Message.html#toAdvancedMessage()">Message</a></code></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>Specified by:</dt>
<dd><code><a href="../Message.html#toAdvancedMessage()">toAdvancedMessage</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<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>
</dl>
</section>
</li>
<li>
<section class="detail" id="create()">
<h3>create</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;V&gt;</span>&nbsp;<span class="return-type"><a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl">ClientMessage</a>&lt;V&gt;</span>&nbsp;<span class="element-name">create</span>()</div>
<div class="block">Creates an empty <a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl"><code>ClientMessage</code></a> instance.</div>
<dl class="notes">
<dt>Type Parameters:</dt>
<dd><code>V</code> - The type of the body value carried in this message.</dd>
<dt>Returns:</dt>
<dd>a new empty <a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl"><code>ClientMessage</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="create(org.apache.qpid.protonj2.types.messaging.Section)">
<h3>create</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;V&gt;</span>&nbsp;<span class="return-type"><a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl">ClientMessage</a>&lt;V&gt;</span>&nbsp;<span class="element-name">create</span><wbr><span class="parameters">(<a href="../../types/messaging/Section.html" title="interface in org.apache.qpid.protonj2.types.messaging">Section</a>&lt;V&gt;&nbsp;body)</span></div>
<div class="block">Creates an <a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl"><code>ClientMessage</code></a> instance with the given body <a href="../../types/messaging/Section.html" title="interface in org.apache.qpid.protonj2.types.messaging"><code>Section</code></a> value.</div>
<dl class="notes">
<dt>Type Parameters:</dt>
<dd><code>V</code> - The type of the body value carried in this message body section.</dd>
<dt>Parameters:</dt>
<dd><code>body</code> - The body <a href="../../types/messaging/Section.html" title="interface in org.apache.qpid.protonj2.types.messaging"><code>Section</code></a> to assign to the created message instance.</dd>
<dt>Returns:</dt>
<dd>a new <a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl"><code>ClientMessage</code></a> instance with the given body.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="createAdvancedMessage()">
<h3>createAdvancedMessage</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;V&gt;</span>&nbsp;<span class="return-type"><a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl">ClientMessage</a>&lt;V&gt;</span>&nbsp;<span class="element-name">createAdvancedMessage</span>()</div>
<div class="block">Creates an empty <a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl"><code>ClientMessage</code></a> instance.</div>
<dl class="notes">
<dt>Type Parameters:</dt>
<dd><code>V</code> - The type of the body value carried in this message.</dd>
<dt>Returns:</dt>
<dd>a new empty <a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl"><code>ClientMessage</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="durable()">
<h3>durable</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">durable</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Message.html#durable()">Message</a></code></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>Specified by:</dt>
<dd><code><a href="../Message.html#durable()">durable</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<dt>Returns:</dt>
<dd>true if the Message is marked as being durable</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="durable(boolean)">
<h3>durable</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl">ClientMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</span>&nbsp;<span class="element-name">durable</span><wbr><span class="parameters">(boolean&nbsp;durable)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Message.html#durable(boolean)">Message</a></code></span></div>
<div class="block">Controls if the message is marked as durable when sent.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Message.html#durable(boolean)">durable</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<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>
</dl>
</section>
</li>
<li>
<section class="detail" id="priority()">
<h3>priority</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">byte</span>&nbsp;<span class="element-name">priority</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Message.html#priority()">priority</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<dt>Returns:</dt>
<dd>the currently configured priority or the default if none set.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="priority(byte)">
<h3>priority</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl">ClientMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</span>&nbsp;<span class="element-name">priority</span><wbr><span class="parameters">(byte&nbsp;priority)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Message.html#priority(byte)">Message</a></code></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>Specified by:</dt>
<dd><code><a href="../Message.html#priority(byte)">priority</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<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>
</dl>
</section>
</li>
<li>
<section class="detail" id="timeToLive()">
<h3>timeToLive</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">timeToLive</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Message.html#timeToLive()">timeToLive</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<dt>Returns:</dt>
<dd>the currently set Time To Live duration (milliseconds).</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="timeToLive(long)">
<h3>timeToLive</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl">ClientMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</span>&nbsp;<span class="element-name">timeToLive</span><wbr><span class="parameters">(long&nbsp;timeToLive)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Message.html#timeToLive(long)">Message</a></code></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>Specified by:</dt>
<dd><code><a href="../Message.html#timeToLive(long)">timeToLive</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<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>
</dl>
</section>
</li>
<li>
<section class="detail" id="firstAcquirer()">
<h3>firstAcquirer</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">firstAcquirer</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Message.html#firstAcquirer()">firstAcquirer</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<dt>Returns:</dt>
<dd>if this message has been acquired by another link previously</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="firstAcquirer(boolean)">
<h3>firstAcquirer</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl">ClientMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</span>&nbsp;<span class="element-name">firstAcquirer</span><wbr><span class="parameters">(boolean&nbsp;firstAcquirer)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Message.html#firstAcquirer(boolean)">Message</a></code></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>Specified by:</dt>
<dd><code><a href="../Message.html#firstAcquirer(boolean)">firstAcquirer</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<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>
</dl>
</section>
</li>
<li>
<section class="detail" id="deliveryCount()">
<h3>deliveryCount</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">deliveryCount</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Message.html#deliveryCount()">deliveryCount</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<dt>Returns:</dt>
<dd>the number of failed delivery attempts that this message has been part of.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="deliveryCount(long)">
<h3>deliveryCount</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl">ClientMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</span>&nbsp;<span class="element-name">deliveryCount</span><wbr><span class="parameters">(long&nbsp;deliveryCount)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Message.html#deliveryCount(long)">Message</a></code></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>Specified by:</dt>
<dd><code><a href="../Message.html#deliveryCount(long)">deliveryCount</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<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>
</dl>
</section>
</li>
<li>
<section class="detail" id="messageId()">
<h3>messageId</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></span>&nbsp;<span class="element-name">messageId</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Message.html#messageId()">messageId</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<dt>Returns:</dt>
<dd>the currently set Message ID or null if none set.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="messageId(java.lang.Object)">
<h3>messageId</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">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></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Message.html#messageId(java.lang.Object)">Message</a></code></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>Specified by:</dt>
<dd><code><a href="../Message.html#messageId(java.lang.Object)">messageId</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<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>
</dl>
</section>
</li>
<li>
<section class="detail" id="userId()">
<h3>userId</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">byte[]</span>&nbsp;<span class="element-name">userId</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Message.html#userId()">userId</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<dt>Returns:</dt>
<dd>the currently set User ID or null if none set.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="userId(byte[])">
<h3>userId</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</span>&nbsp;<span class="element-name">userId</span><wbr><span class="parameters">(byte[]&nbsp;userId)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Message.html#userId(byte%5B%5D)">Message</a></code></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>Specified by:</dt>
<dd><code><a href="../Message.html#userId(byte%5B%5D)">userId</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<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>
</dl>
</section>
</li>
<li>
<section class="detail" id="to()">
<h3>to</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">to</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Message.html#to()">to</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<dt>Returns:</dt>
<dd>the currently set 'To' address which indicates the intended destination of the message.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="to(java.lang.String)">
<h3>to</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">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></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Message.html#to(java.lang.String)">Message</a></code></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>Specified by:</dt>
<dd><code><a href="../Message.html#to(java.lang.String)">to</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<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>
</dl>
</section>
</li>
<li>
<section class="detail" id="subject()">
<h3>subject</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">subject</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Message.html#subject()">subject</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<dt>Returns:</dt>
<dd>the currently set subject metadata for this message or null if none set.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="subject(java.lang.String)">
<h3>subject</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">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></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Message.html#subject(java.lang.String)">Message</a></code></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>Specified by:</dt>
<dd><code><a href="../Message.html#subject(java.lang.String)">subject</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<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>
</dl>
</section>
</li>
<li>
<section class="detail" id="replyTo()">
<h3>replyTo</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">replyTo</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Message.html#replyTo()">replyTo</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<dt>Returns:</dt>
<dd>the configured address of the node where replies to this message should be sent, or null if not set.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="replyTo(java.lang.String)">
<h3>replyTo</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">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></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Message.html#replyTo(java.lang.String)">Message</a></code></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>Specified by:</dt>
<dd><code><a href="../Message.html#replyTo(java.lang.String)">replyTo</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<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>
</dl>
</section>
</li>
<li>
<section class="detail" id="correlationId()">
<h3>correlationId</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></span>&nbsp;<span class="element-name">correlationId</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Message.html#correlationId()">correlationId</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<dt>Returns:</dt>
<dd>the currently assigned correlation ID or null if none set.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="correlationId(java.lang.Object)">
<h3>correlationId</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">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></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Message.html#correlationId(java.lang.Object)">Message</a></code></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>Specified by:</dt>
<dd><code><a href="../Message.html#correlationId(java.lang.Object)">correlationId</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<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>
</dl>
</section>
</li>
<li>
<section class="detail" id="contentType()">
<h3>contentType</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">contentType</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Message.html#contentType()">contentType</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<dt>Returns:</dt>
<dd>the assigned content type value for the message body section or null if not set.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="contentType(java.lang.String)">
<h3>contentType</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">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></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Message.html#contentType(java.lang.String)">Message</a></code></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>Specified by:</dt>
<dd><code><a href="../Message.html#contentType(java.lang.String)">contentType</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<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>
</dl>
</section>
</li>
<li>
<section class="detail" id="contentEncoding()">
<h3>contentEncoding</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">contentEncoding</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Message.html#contentEncoding()">contentEncoding</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<dt>Returns:</dt>
<dd>the assigned content encoding value for the message body section or null if not set.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="contentEncoding(java.lang.String)">
<h3>contentEncoding</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&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></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Message.html#contentEncoding(java.lang.String)">Message</a></code></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>Specified by:</dt>
<dd><code><a href="../Message.html#contentEncoding(java.lang.String)">contentEncoding</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<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>
</dl>
</section>
</li>
<li>
<section class="detail" id="absoluteExpiryTime()">
<h3>absoluteExpiryTime</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">absoluteExpiryTime</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Message.html#absoluteExpiryTime()">absoluteExpiryTime</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<dt>Returns:</dt>
<dd>the configured absolute time of expiration for this message.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="absoluteExpiryTime(long)">
<h3>absoluteExpiryTime</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</span>&nbsp;<span class="element-name">absoluteExpiryTime</span><wbr><span class="parameters">(long&nbsp;expiryTime)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Message.html#absoluteExpiryTime(long)">Message</a></code></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>Specified by:</dt>
<dd><code><a href="../Message.html#absoluteExpiryTime(long)">absoluteExpiryTime</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<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>
</dl>
</section>
</li>
<li>
<section class="detail" id="creationTime()">
<h3>creationTime</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">creationTime</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Message.html#creationTime()">creationTime</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<dt>Returns:</dt>
<dd>the absolute time of creation for this message.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="creationTime(long)">
<h3>creationTime</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</span>&nbsp;<span class="element-name">creationTime</span><wbr><span class="parameters">(long&nbsp;createTime)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Message.html#creationTime(long)">Message</a></code></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>Specified by:</dt>
<dd><code><a href="../Message.html#creationTime(long)">creationTime</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<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>
</dl>
</section>
</li>
<li>
<section class="detail" id="groupId()">
<h3>groupId</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">groupId</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Message.html#groupId()">groupId</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<dt>Returns:</dt>
<dd>the assigned group ID for this message or null if not set.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="groupId(java.lang.String)">
<h3>groupId</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">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></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Message.html#groupId(java.lang.String)">Message</a></code></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>Specified by:</dt>
<dd><code><a href="../Message.html#groupId(java.lang.String)">groupId</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<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>
</dl>
</section>
</li>
<li>
<section class="detail" id="groupSequence()">
<h3>groupSequence</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">groupSequence</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Message.html#groupSequence()">groupSequence</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<dt>Returns:</dt>
<dd>the assigned group sequence for this message.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="groupSequence(int)">
<h3>groupSequence</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</span>&nbsp;<span class="element-name">groupSequence</span><wbr><span class="parameters">(int&nbsp;groupSequence)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Message.html#groupSequence(int)">Message</a></code></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>Specified by:</dt>
<dd><code><a href="../Message.html#groupSequence(int)">groupSequence</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<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>
</dl>
</section>
</li>
<li>
<section class="detail" id="replyToGroupId()">
<h3>replyToGroupId</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">replyToGroupId</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Message.html#replyToGroupId()">replyToGroupId</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<dt>Returns:</dt>
<dd>the client-specific id used so that client can send replies to this message to a specific group.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="replyToGroupId(java.lang.String)">
<h3>replyToGroupId</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">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></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Message.html#replyToGroupId(java.lang.String)">Message</a></code></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>Specified by:</dt>
<dd><code><a href="../Message.html#replyToGroupId(java.lang.String)">replyToGroupId</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<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>
</dl>
</section>
</li>
<li>
<section class="detail" id="annotation(java.lang.String)">
<h3>annotation</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/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></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Message.html#annotation(java.lang.String)">Message</a></code></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>Specified by:</dt>
<dd><code><a href="../Message.html#annotation(java.lang.String)">annotation</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<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>
</dl>
</section>
</li>
<li>
<section class="detail" id="hasAnnotation(java.lang.String)">
<h3>hasAnnotation</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<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></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Message.html#hasAnnotation(java.lang.String)">Message</a></code></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>Specified by:</dt>
<dd><code><a href="../Message.html#hasAnnotation(java.lang.String)">hasAnnotation</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<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>
</dl>
</section>
</li>
<li>
<section class="detail" id="hasAnnotations()">
<h3>hasAnnotations</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">hasAnnotations</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Message.html#hasAnnotations()">Message</a></code></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>Specified by:</dt>
<dd><code><a href="../Message.html#hasAnnotations()">hasAnnotations</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<dt>Returns:</dt>
<dd><code>true</code> if the Message carries any message annotations.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="removeAnnotation(java.lang.String)">
<h3>removeAnnotation</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/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></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Message.html#removeAnnotation(java.lang.String)">Message</a></code></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>Specified by:</dt>
<dd><code><a href="../Message.html#removeAnnotation(java.lang.String)">removeAnnotation</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<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>
</dl>
</section>
</li>
<li>
<section class="detail" id="forEachAnnotation(java.util.function.BiConsumer)">
<h3>forEachAnnotation</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">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></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Message.html#forEachAnnotation(java.util.function.BiConsumer)">Message</a></code></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>Specified by:</dt>
<dd><code><a href="../Message.html#forEachAnnotation(java.util.function.BiConsumer)">forEachAnnotation</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<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>
</dl>
</section>
</li>
<li>
<section class="detail" id="annotation(java.lang.String,java.lang.Object)">
<h3>annotation</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl">ClientMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">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></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Message.html#annotation(java.lang.String,java.lang.Object)">Message</a></code></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>Specified by:</dt>
<dd><code><a href="../Message.html#annotation(java.lang.String,java.lang.Object)">annotation</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<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>
</dl>
</section>
</li>
<li>
<section class="detail" id="property(java.lang.String)">
<h3>property</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/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></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Message.html#property(java.lang.String)">Message</a></code></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>Specified by:</dt>
<dd><code><a href="../Message.html#property(java.lang.String)">property</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<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>
</dl>
</section>
</li>
<li>
<section class="detail" id="hasProperty(java.lang.String)">
<h3>hasProperty</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<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></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Message.html#hasProperty(java.lang.String)">Message</a></code></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>Specified by:</dt>
<dd><code><a href="../Message.html#hasProperty(java.lang.String)">hasProperty</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<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>
</dl>
</section>
</li>
<li>
<section class="detail" id="hasProperties()">
<h3>hasProperties</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">hasProperties</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Message.html#hasProperties()">Message</a></code></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>Specified by:</dt>
<dd><code><a href="../Message.html#hasProperties()">hasProperties</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<dt>Returns:</dt>
<dd><code>true</code> if the Message carries any application properties.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="removeProperty(java.lang.String)">
<h3>removeProperty</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/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></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Message.html#removeProperty(java.lang.String)">Message</a></code></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>Specified by:</dt>
<dd><code><a href="../Message.html#removeProperty(java.lang.String)">removeProperty</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<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>
</dl>
</section>
</li>
<li>
<section class="detail" id="forEachProperty(java.util.function.BiConsumer)">
<h3>forEachProperty</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">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></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Message.html#forEachProperty(java.util.function.BiConsumer)">Message</a></code></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>Specified by:</dt>
<dd><code><a href="../Message.html#forEachProperty(java.util.function.BiConsumer)">forEachProperty</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<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>
</dl>
</section>
</li>
<li>
<section class="detail" id="property(java.lang.String,java.lang.Object)">
<h3>property</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl">ClientMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">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></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Message.html#property(java.lang.String,java.lang.Object)">Message</a></code></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>Specified by:</dt>
<dd><code><a href="../Message.html#property(java.lang.String,java.lang.Object)">property</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<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>
</dl>
</section>
</li>
<li>
<section class="detail" id="footer(java.lang.String)">
<h3>footer</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/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></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Message.html#footer(java.lang.String)">Message</a></code></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>Specified by:</dt>
<dd><code><a href="../Message.html#footer(java.lang.String)">footer</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<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>
</dl>
</section>
</li>
<li>
<section class="detail" id="hasFooter(java.lang.String)">
<h3>hasFooter</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<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></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Message.html#hasFooter(java.lang.String)">Message</a></code></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>Specified by:</dt>
<dd><code><a href="../Message.html#hasFooter(java.lang.String)">hasFooter</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<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>
</dl>
</section>
</li>
<li>
<section class="detail" id="hasFooters()">
<h3>hasFooters</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">hasFooters</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Message.html#hasFooters()">Message</a></code></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>Specified by:</dt>
<dd><code><a href="../Message.html#hasFooters()">hasFooters</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<dt>Returns:</dt>
<dd><code>true</code> if the Message carries any footers.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="removeFooter(java.lang.String)">
<h3>removeFooter</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/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></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Message.html#removeFooter(java.lang.String)">Message</a></code></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>Specified by:</dt>
<dd><code><a href="../Message.html#removeFooter(java.lang.String)">removeFooter</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<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>
</dl>
</section>
</li>
<li>
<section class="detail" id="forEachFooter(java.util.function.BiConsumer)">
<h3>forEachFooter</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">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></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Message.html#forEachFooter(java.util.function.BiConsumer)">Message</a></code></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>Specified by:</dt>
<dd><code><a href="../Message.html#forEachFooter(java.util.function.BiConsumer)">forEachFooter</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<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>
</dl>
</section>
</li>
<li>
<section class="detail" id="footer(java.lang.String,java.lang.Object)">
<h3>footer</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl">ClientMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">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></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Message.html#footer(java.lang.String,java.lang.Object)">Message</a></code></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>Specified by:</dt>
<dd><code><a href="../Message.html#footer(java.lang.String,java.lang.Object)">footer</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<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>
</dl>
</section>
</li>
<li>
<section class="detail" id="body()">
<h3>body</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ClientMessage.html" title="type parameter in ClientMessage">E</a></span>&nbsp;<span class="element-name">body</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Message.html#body()">Message</a></code></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>Specified by:</dt>
<dd><code><a href="../Message.html#body()">body</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<dt>Returns:</dt>
<dd>the message body value or null if none present.</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="modifiers">public</span>&nbsp;<span class="return-type"><a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl">ClientMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</span>&nbsp;<span class="element-name">body</span><wbr><span class="parameters">(<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&nbsp;value)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Message.html#body(E)">Message</a></code></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>Specified by:</dt>
<dd><code><a href="../Message.html#body(E)">body</a></code>&nbsp;in interface&nbsp;<code><a href="../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<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>
</dl>
</section>
</li>
<li>
<section class="detail" id="header()">
<h3>header</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../../types/messaging/Header.html" title="class in org.apache.qpid.protonj2.types.messaging">Header</a></span>&nbsp;<span class="element-name">header</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../AdvancedMessage.html#header()">AdvancedMessage</a></code></span></div>
<div class="block">Return the current <a href="../../types/messaging/Header.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>Header</code></a> assigned to this message, if none was assigned yet
 then this method returns <code>null</code>.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../AdvancedMessage.html#header()">header</a></code>&nbsp;in interface&nbsp;<code><a href="../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client">AdvancedMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<dt>Returns:</dt>
<dd>the currently assigned <a href="../../types/messaging/Header.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>Header</code></a> for this message.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="header(org.apache.qpid.protonj2.types.messaging.Header)">
<h3>header</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl">ClientMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</span>&nbsp;<span class="element-name">header</span><wbr><span class="parameters">(<a href="../../types/messaging/Header.html" title="class in org.apache.qpid.protonj2.types.messaging">Header</a>&nbsp;header)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../AdvancedMessage.html#header(org.apache.qpid.protonj2.types.messaging.Header)">AdvancedMessage</a></code></span></div>
<div class="block">Assign or replace the <a href="../../types/messaging/Header.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>Header</code></a> instance associated with this message.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../AdvancedMessage.html#header(org.apache.qpid.protonj2.types.messaging.Header)">header</a></code>&nbsp;in interface&nbsp;<code><a href="../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client">AdvancedMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<dt>Parameters:</dt>
<dd><code>header</code> - The <a href="../../types/messaging/Header.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>Header</code></a> value to assign to this message.</dd>
<dt>Returns:</dt>
<dd>this <a href="../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client"><code>AdvancedMessage</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="annotations()">
<h3>annotations</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../../types/messaging/MessageAnnotations.html" title="class in org.apache.qpid.protonj2.types.messaging">MessageAnnotations</a></span>&nbsp;<span class="element-name">annotations</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../AdvancedMessage.html#annotations()">AdvancedMessage</a></code></span></div>
<div class="block">Return the current <a href="../../types/messaging/MessageAnnotations.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>MessageAnnotations</code></a> assigned to this message, if none was assigned yet
 then this method returns <code>null</code>.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../AdvancedMessage.html#annotations()">annotations</a></code>&nbsp;in interface&nbsp;<code><a href="../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client">AdvancedMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<dt>Returns:</dt>
<dd>the currently assigned <a href="../../types/messaging/MessageAnnotations.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>MessageAnnotations</code></a> for this message.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="annotations(org.apache.qpid.protonj2.types.messaging.MessageAnnotations)">
<h3>annotations</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl">ClientMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</span>&nbsp;<span class="element-name">annotations</span><wbr><span class="parameters">(<a href="../../types/messaging/MessageAnnotations.html" title="class in org.apache.qpid.protonj2.types.messaging">MessageAnnotations</a>&nbsp;messageAnnotations)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../AdvancedMessage.html#annotations(org.apache.qpid.protonj2.types.messaging.MessageAnnotations)">AdvancedMessage</a></code></span></div>
<div class="block">Assign or replace the <a href="../../types/messaging/MessageAnnotations.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>MessageAnnotations</code></a> instance associated with this message.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../AdvancedMessage.html#annotations(org.apache.qpid.protonj2.types.messaging.MessageAnnotations)">annotations</a></code>&nbsp;in interface&nbsp;<code><a href="../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client">AdvancedMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<dt>Parameters:</dt>
<dd><code>messageAnnotations</code> - The <a href="../../types/messaging/MessageAnnotations.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>MessageAnnotations</code></a> value to assign to this message.</dd>
<dt>Returns:</dt>
<dd>this <a href="../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client"><code>AdvancedMessage</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="properties()">
<h3>properties</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../../types/messaging/Properties.html" title="class in org.apache.qpid.protonj2.types.messaging">Properties</a></span>&nbsp;<span class="element-name">properties</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../AdvancedMessage.html#properties()">AdvancedMessage</a></code></span></div>
<div class="block">Return the current <a href="../../types/messaging/Properties.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>Properties</code></a> assigned to this message, if none was assigned yet
 then this method returns <code>null</code>.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../AdvancedMessage.html#properties()">properties</a></code>&nbsp;in interface&nbsp;<code><a href="../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client">AdvancedMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<dt>Returns:</dt>
<dd>the currently assigned <a href="../../types/messaging/Properties.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>Properties</code></a> for this message.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="properties(org.apache.qpid.protonj2.types.messaging.Properties)">
<h3>properties</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl">ClientMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</span>&nbsp;<span class="element-name">properties</span><wbr><span class="parameters">(<a href="../../types/messaging/Properties.html" title="class in org.apache.qpid.protonj2.types.messaging">Properties</a>&nbsp;properties)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../AdvancedMessage.html#properties(org.apache.qpid.protonj2.types.messaging.Properties)">AdvancedMessage</a></code></span></div>
<div class="block">Assign or replace the <a href="../../types/messaging/Properties.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>Properties</code></a> instance associated with this message.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../AdvancedMessage.html#properties(org.apache.qpid.protonj2.types.messaging.Properties)">properties</a></code>&nbsp;in interface&nbsp;<code><a href="../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client">AdvancedMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<dt>Parameters:</dt>
<dd><code>properties</code> - The <a href="../../types/messaging/Properties.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>Properties</code></a> value to assign to this message.</dd>
<dt>Returns:</dt>
<dd>this <a href="../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client"><code>AdvancedMessage</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="applicationProperties()">
<h3>applicationProperties</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../../types/messaging/ApplicationProperties.html" title="class in org.apache.qpid.protonj2.types.messaging">ApplicationProperties</a></span>&nbsp;<span class="element-name">applicationProperties</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../AdvancedMessage.html#applicationProperties()">AdvancedMessage</a></code></span></div>
<div class="block">Return the current <a href="../../types/messaging/ApplicationProperties.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>ApplicationProperties</code></a> assigned to this message, if none was assigned yet
 then this method returns <code>null</code>.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../AdvancedMessage.html#applicationProperties()">applicationProperties</a></code>&nbsp;in interface&nbsp;<code><a href="../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client">AdvancedMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<dt>Returns:</dt>
<dd>the currently assigned <a href="../../types/messaging/ApplicationProperties.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>ApplicationProperties</code></a> for this message.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="applicationProperties(org.apache.qpid.protonj2.types.messaging.ApplicationProperties)">
<h3>applicationProperties</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl">ClientMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</span>&nbsp;<span class="element-name">applicationProperties</span><wbr><span class="parameters">(<a href="../../types/messaging/ApplicationProperties.html" title="class in org.apache.qpid.protonj2.types.messaging">ApplicationProperties</a>&nbsp;applicationProperties)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../AdvancedMessage.html#applicationProperties(org.apache.qpid.protonj2.types.messaging.ApplicationProperties)">AdvancedMessage</a></code></span></div>
<div class="block">Assign or replace the <a href="../../types/messaging/ApplicationProperties.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>ApplicationProperties</code></a> instance associated with this message.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../AdvancedMessage.html#applicationProperties(org.apache.qpid.protonj2.types.messaging.ApplicationProperties)">applicationProperties</a></code>&nbsp;in interface&nbsp;<code><a href="../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client">AdvancedMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<dt>Parameters:</dt>
<dd><code>applicationProperties</code> - The <a href="../../types/messaging/ApplicationProperties.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>ApplicationProperties</code></a> value to assign to this message.</dd>
<dt>Returns:</dt>
<dd>this <a href="../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client"><code>AdvancedMessage</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="footer()">
<h3>footer</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../../types/messaging/Footer.html" title="class in org.apache.qpid.protonj2.types.messaging">Footer</a></span>&nbsp;<span class="element-name">footer</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../AdvancedMessage.html#footer()">AdvancedMessage</a></code></span></div>
<div class="block">Return the current <a href="../../types/messaging/Footer.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>Footer</code></a> assigned to this message, if none was assigned yet
 then this method returns <code>null</code>.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../AdvancedMessage.html#footer()">footer</a></code>&nbsp;in interface&nbsp;<code><a href="../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client">AdvancedMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<dt>Returns:</dt>
<dd>the currently assigned <a href="../../types/messaging/Footer.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>Footer</code></a> for this message.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="footer(org.apache.qpid.protonj2.types.messaging.Footer)">
<h3>footer</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl">ClientMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</span>&nbsp;<span class="element-name">footer</span><wbr><span class="parameters">(<a href="../../types/messaging/Footer.html" title="class in org.apache.qpid.protonj2.types.messaging">Footer</a>&nbsp;footer)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../AdvancedMessage.html#footer(org.apache.qpid.protonj2.types.messaging.Footer)">AdvancedMessage</a></code></span></div>
<div class="block">Assign or replace the <a href="../../types/messaging/Footer.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>Footer</code></a> instance associated with this message.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../AdvancedMessage.html#footer(org.apache.qpid.protonj2.types.messaging.Footer)">footer</a></code>&nbsp;in interface&nbsp;<code><a href="../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client">AdvancedMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<dt>Parameters:</dt>
<dd><code>footer</code> - The <a href="../../types/messaging/Footer.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>Footer</code></a> value to assign to this message.</dd>
<dt>Returns:</dt>
<dd>this <a href="../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client"><code>AdvancedMessage</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="messageFormat()">
<h3>messageFormat</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">messageFormat</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../AdvancedMessage.html#messageFormat()">messageFormat</a></code>&nbsp;in interface&nbsp;<code><a href="../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client">AdvancedMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<dt>Returns:</dt>
<dd>the currently assigned message format for this message.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="messageFormat(int)">
<h3>messageFormat</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl">ClientMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</span>&nbsp;<span class="element-name">messageFormat</span><wbr><span class="parameters">(int&nbsp;messageFormat)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../AdvancedMessage.html#messageFormat(int)">AdvancedMessage</a></code></span></div>
<div class="block">Sets the message format to use when the message is sent.  The exact structure of a
 message, together with its encoding, is defined by the message format (default is
 the AMQP defined message format zero.
 <p>
 This field MUST be specified for the first transfer of a multi-transfer message, if
 it is not set at the time of send of the first transfer the sender uses the AMQP
 default value of zero for this field.
 <p>
 The upper three octets of a message format code identify a particular message format.
 The lowest octet indicates the version of said message format. Any given version of
 a format is forwards compatible with all higher versions.
 <pre>

       3 octets      1 octet
    +----------------+---------+
    | message format | version |
    +----------------+---------+
    |                          |
   msb                        lsb

 </pre></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../AdvancedMessage.html#messageFormat(int)">messageFormat</a></code>&nbsp;in interface&nbsp;<code><a href="../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client">AdvancedMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<dt>Parameters:</dt>
<dd><code>messageFormat</code> - The message format to encode into the transfer frame that carries the message.</dd>
<dt>Returns:</dt>
<dd>this <a href="../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client"><code>AdvancedMessage</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="encode(java.util.Map,org.apache.qpid.protonj2.buffer.ProtonBufferAllocator)">
<h3>encode</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></span>&nbsp;<span class="element-name">encode</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;deliveryAnnotations,
 <a href="../../buffer/ProtonBufferAllocator.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferAllocator</a>&nbsp;allocator)</span>
                    throws <span class="exceptions"><a href="../exceptions/ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../AdvancedMessage.html#encode(java.util.Map,org.apache.qpid.protonj2.buffer.ProtonBufferAllocator)">AdvancedMessage</a></code></span></div>
<div class="block">Encodes the <a href="../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client"><code>AdvancedMessage</code></a> for transmission by the client.  The provided <a href="../../types/messaging/DeliveryAnnotations.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>DeliveryAnnotations</code></a>
 can be included or augmented by the <a href="../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client"><code>AdvancedMessage</code></a> implementation based on the target message format.
 The implementation is responsible for ensuring that the delivery annotations are treated correctly encoded into
 the correct location in the message.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../AdvancedMessage.html#encode(java.util.Map,org.apache.qpid.protonj2.buffer.ProtonBufferAllocator)">encode</a></code>&nbsp;in interface&nbsp;<code><a href="../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client">AdvancedMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<dt>Parameters:</dt>
<dd><code>deliveryAnnotations</code> - A <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> of delivery annotation values that were requested to be included in the transmitted message.</dd>
<dd><code>allocator</code> - An allocator that should be used to create the buffer the message is encoded into.</dd>
<dt>Returns:</dt>
<dd>the encoded form of this message in a <a href="../../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer"><code>ProtonBuffer</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 encoding the message data.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="addBodySection(org.apache.qpid.protonj2.types.messaging.Section)">
<h3>addBodySection</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl">ClientMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</span>&nbsp;<span class="element-name">addBodySection</span><wbr><span class="parameters">(<a href="../../types/messaging/Section.html" title="interface in org.apache.qpid.protonj2.types.messaging">Section</a>&lt;?&gt;&nbsp;bodySection)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../AdvancedMessage.html#addBodySection(org.apache.qpid.protonj2.types.messaging.Section)">AdvancedMessage</a></code></span></div>
<div class="block">Adds the given <a href="../../types/messaging/Section.html" title="interface in org.apache.qpid.protonj2.types.messaging"><code>Section</code></a> to the internal collection of sections that will be sent
 to the remote peer when this message is encoded.  If a previous section was added by a call
 to the <a href="../Message.html#body(E)"><code>Message.body(Object)</code></a> method it should be retained as the first element of
 the running list of body sections contained in this message.
 <p>
 The implementation should make an attempt to validate that sections added are valid for
 the message format that is assigned when they are added.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../AdvancedMessage.html#addBodySection(org.apache.qpid.protonj2.types.messaging.Section)">addBodySection</a></code>&nbsp;in interface&nbsp;<code><a href="../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client">AdvancedMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<dt>Parameters:</dt>
<dd><code>bodySection</code> - The <a href="../../types/messaging/Section.html" title="interface in org.apache.qpid.protonj2.types.messaging"><code>Section</code></a> instance to append to the internal collection.</dd>
<dt>Returns:</dt>
<dd>this <a href="../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client"><code>AdvancedMessage</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="bodySections(java.util.Collection)">
<h3>bodySections</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl">ClientMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</span>&nbsp;<span class="element-name">bodySections</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;<a href="../../types/messaging/Section.html" title="interface in org.apache.qpid.protonj2.types.messaging">Section</a>&lt;?&gt;&gt;&nbsp;sections)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../AdvancedMessage.html#bodySections(java.util.Collection)">AdvancedMessage</a></code></span></div>
<div class="block">Sets the body <a href="../../types/messaging/Section.html" title="interface in org.apache.qpid.protonj2.types.messaging"><code>Section</code></a> instances to use when encoding this message.  The value
 given replaces any existing sections assigned to this message through the <a href="../Message.html#body(E)"><code>Message.body(Object)</code></a>
 or <a href="../AdvancedMessage.html#addBodySection(org.apache.qpid.protonj2.types.messaging.Section)"><code>AdvancedMessage.addBodySection(Section)</code></a> methods.  Calling this method with a null
 or empty collection is equivalent to calling the <a href="../AdvancedMessage.html#clearBodySections()"><code>AdvancedMessage.clearBodySections()</code></a> method.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../AdvancedMessage.html#bodySections(java.util.Collection)">bodySections</a></code>&nbsp;in interface&nbsp;<code><a href="../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client">AdvancedMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<dt>Parameters:</dt>
<dd><code>sections</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link"><code>Collection</code></a> of <a href="../../types/messaging/Section.html" title="interface in org.apache.qpid.protonj2.types.messaging"><code>Section</code></a> instance to assign this message.</dd>
<dt>Returns:</dt>
<dd>this <a href="../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client"><code>AdvancedMessage</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="bodySections()">
<h3>bodySections</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;<a href="../../types/messaging/Section.html" title="interface in org.apache.qpid.protonj2.types.messaging">Section</a>&lt;?&gt;&gt;</span>&nbsp;<span class="element-name">bodySections</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../AdvancedMessage.html#bodySections()">AdvancedMessage</a></code></span></div>
<div class="block">Create and return an unmodifiable <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link"><code>Collection</code></a> that contains the <a href="../../types/messaging/Section.html" title="interface in org.apache.qpid.protonj2.types.messaging"><code>Section</code></a> instances
 currently assigned to this message.  Changes to this message body after calling this will not be
 reflected in the returned collection.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../AdvancedMessage.html#bodySections()">bodySections</a></code>&nbsp;in interface&nbsp;<code><a href="../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client">AdvancedMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<dt>Returns:</dt>
<dd>an unmodifiable <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link"><code>Collection</code></a> that is a view of the current sections assigned to this message.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="forEachBodySection(java.util.function.Consumer)">
<h3>forEachBodySection</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl">ClientMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</span>&nbsp;<span class="element-name">forEachBodySection</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/function/Consumer.html" title="class or interface in java.util.function" class="external-link">Consumer</a>&lt;<a href="../../types/messaging/Section.html" title="interface in org.apache.qpid.protonj2.types.messaging">Section</a>&lt;?&gt;&gt;&nbsp;consumer)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../AdvancedMessage.html#forEachBodySection(java.util.function.Consumer)">AdvancedMessage</a></code></span></div>
<div class="block">Performs the given action for each body <a href="../../types/messaging/Section.html" title="interface in org.apache.qpid.protonj2.types.messaging"><code>Section</code></a> of the <a href="../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client"><code>AdvancedMessage</code></a> until all
 sections have been presented to the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/function/Consumer.html" title="class or interface in java.util.function" class="external-link"><code>Consumer</code></a> or the consumer throws an exception.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../AdvancedMessage.html#forEachBodySection(java.util.function.Consumer)">forEachBodySection</a></code>&nbsp;in interface&nbsp;<code><a href="../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client">AdvancedMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<dt>Parameters:</dt>
<dd><code>consumer</code> - the <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/function/Consumer.html" title="class or interface in java.util.function" class="external-link"><code>Consumer</code></a> that will operate on each of the body sections in this message.</dd>
<dt>Returns:</dt>
<dd>this <a href="../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client"><code>AdvancedMessage</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="clearBodySections()">
<h3>clearBodySections</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl">ClientMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</span>&nbsp;<span class="element-name">clearBodySections</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../AdvancedMessage.html#clearBodySections()">AdvancedMessage</a></code></span></div>
<div class="block">Clears all current body <a href="../../types/messaging/Section.html" title="interface in org.apache.qpid.protonj2.types.messaging"><code>Section</code></a> elements from the <a href="../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client"><code>AdvancedMessage</code></a>.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../AdvancedMessage.html#clearBodySections()">clearBodySections</a></code>&nbsp;in interface&nbsp;<code><a href="../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client">AdvancedMessage</a>&lt;<a href="ClientMessage.html" title="type parameter in ClientMessage">E</a>&gt;</code></dd>
<dt>Returns:</dt>
<dd>this <a href="../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client"><code>AdvancedMessage</code></a> instance.</dd>
</dl>
</section>
</li>
</ul>
</section>
</li>
</ul>
</section>
<!-- ========= END OF CLASS DATA ========= -->
</main>
<footer role="contentinfo">
<hr>
<p class="legal-copy"><small>Copyright &#169; 2023 <a href="https://www.apache.org/">The Apache Software Foundation</a>. All rights reserved.</small></p>
</footer>
</div>
</div>
</body>
</html>
