<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>Encoder (Qpid ProtonJ2 Parent 1.0.0-M19 API)</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<meta name="description" content="declaration: package: org.apache.qpid.protonj2.codec, interface: Encoder">
<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/Encoder.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.codec</a></div>
<h1 title="Interface Encoder" class="title">Interface Encoder</h1>
</div>
<section class="class-description" id="class-description">
<dl class="notes">
<dt>All Known Implementing Classes:</dt>
<dd><code><a href="encoders/ProtonEncoder.html" title="class in org.apache.qpid.protonj2.codec.encoders">ProtonEncoder</a></code></dd>
</dl>
<hr>
<div class="type-signature"><span class="modifiers">public interface </span><span class="element-name type-name-label">Encoder</span></div>
<div class="block">Encode AMQP types into binary streams</div>
</section>
<section class="summary">
<ul class="summary-list">
<!-- ========== METHOD SUMMARY =========== -->
<li>
<section class="method-summary" id="method-summary">
<h2>Method Summary</h2>
<div id="method-summary-table">
<div class="table-tabs" role="tablist" aria-orientation="horizontal"><button id="method-summary-table-tab0" role="tab" aria-selected="true" aria-controls="method-summary-table.tabpanel" tabindex="0" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table', 3)" class="active-table-tab">All Methods</button><button id="method-summary-table-tab2" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab2', 3)" class="table-tab">Instance Methods</button><button id="method-summary-table-tab3" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab3', 3)" class="table-tab">Abstract Methods</button></div>
<div id="method-summary-table.tabpanel" role="tabpanel">
<div class="summary-table three-column-summary" aria-labelledby="method-summary-table-tab0">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Method</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#getCachedEncoderState()" class="member-name-link">getCachedEncoderState</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Return a singleton <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> instance that is meant to be shared within single threaded
 encoder interactions.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="TypeEncoder.html" title="interface in org.apache.qpid.protonj2.codec">TypeEncoder</a>&lt;?&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#getTypeEncoder(java.lang.Class)" class="member-name-link">getTypeEncoder</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Class.html" title="class or interface in java.lang" class="external-link">Class</a>&lt;?&gt;&nbsp;typeClass)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Lookup a <a href="TypeEncoder.html" title="interface in org.apache.qpid.protonj2.codec"><code>TypeEncoder</code></a> that would be used to encode the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Class.html" title="class or interface in java.lang" class="external-link"><code>Class</code></a>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="TypeEncoder.html" title="interface in org.apache.qpid.protonj2.codec">TypeEncoder</a>&lt;?&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#getTypeEncoder(java.lang.Object)" class="member-name-link">getTypeEncoder</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;value)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Lookup a <a href="TypeEncoder.html" title="interface in org.apache.qpid.protonj2.codec"><code>TypeEncoder</code></a> that would be used to encode the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link"><code>Object</code></a>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#newEncoderState()" class="member-name-link">newEncoderState</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Creates a new <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> instance that can be used when interacting with the
 Encoder.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>&lt;V&gt;&nbsp;<a href="Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#registerDescribedTypeEncoder(org.apache.qpid.protonj2.codec.DescribedTypeEncoder)" class="member-name-link">registerDescribedTypeEncoder</a><wbr>(<a href="DescribedTypeEncoder.html" title="interface in org.apache.qpid.protonj2.codec">DescribedTypeEncoder</a>&lt;V&gt;&nbsp;encoder)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Register a <a href="DescribedTypeEncoder.html" title="interface in org.apache.qpid.protonj2.codec"><code>DescribedTypeEncoder</code></a> which can be used when writing custom types using this
 encoder.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,boolean%5B%5D)" class="member-name-link">writeArray</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 boolean[]&nbsp;value)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write the given array as with the proper array type encoding to the given buffer.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,byte%5B%5D)" class="member-name-link">writeArray</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 byte[]&nbsp;value)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write the given array as with the proper array type encoding to the given buffer.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,char%5B%5D)" class="member-name-link">writeArray</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 char[]&nbsp;value)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write the given array as with the proper array type encoding to the given buffer.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,double%5B%5D)" class="member-name-link">writeArray</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 double[]&nbsp;value)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write the given array as with the proper array type encoding to the given buffer.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,float%5B%5D)" class="member-name-link">writeArray</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 float[]&nbsp;value)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write the given array as with the proper array type encoding to the given buffer.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,int%5B%5D)" class="member-name-link">writeArray</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 int[]&nbsp;value)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write the given array as with the proper array type encoding to the given buffer.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,long%5B%5D)" class="member-name-link">writeArray</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 long[]&nbsp;value)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write the given array as with the proper array type encoding to the given buffer.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,short%5B%5D)" class="member-name-link">writeArray</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 short[]&nbsp;value)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write the given array as with the proper array type encoding to the given buffer.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.lang.Object%5B%5D)" class="member-name-link">writeArray</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>[]&nbsp;value)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write the given array as with the proper array type encoding to the given buffer.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.util.UUID%5B%5D)" class="member-name-link">writeArray</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/UUID.html" title="class or interface in java.util" class="external-link">UUID</a>[]&nbsp;value)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write the given array as with the proper array type encoding to the given buffer.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.Decimal128%5B%5D)" class="member-name-link">writeArray</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="../types/Decimal128.html" title="class in org.apache.qpid.protonj2.types">Decimal128</a>[]&nbsp;value)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write the given array as with the proper array type encoding to the given buffer.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.Decimal32%5B%5D)" class="member-name-link">writeArray</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="../types/Decimal32.html" title="class in org.apache.qpid.protonj2.types">Decimal32</a>[]&nbsp;value)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write the given array as with the proper array type encoding to the given buffer.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.Decimal64%5B%5D)" class="member-name-link">writeArray</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="../types/Decimal64.html" title="class in org.apache.qpid.protonj2.types">Decimal64</a>[]&nbsp;value)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write the given array as with the proper array type encoding to the given buffer.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.Symbol%5B%5D)" class="member-name-link">writeArray</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="../types/Symbol.html" title="class in org.apache.qpid.protonj2.types">Symbol</a>[]&nbsp;value)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write the given array as with the proper array type encoding to the given buffer.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.UnsignedByte%5B%5D)" class="member-name-link">writeArray</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="../types/UnsignedByte.html" title="class in org.apache.qpid.protonj2.types">UnsignedByte</a>[]&nbsp;value)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write the given array as with the proper array type encoding to the given buffer.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.UnsignedInteger%5B%5D)" class="member-name-link">writeArray</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="../types/UnsignedInteger.html" title="class in org.apache.qpid.protonj2.types">UnsignedInteger</a>[]&nbsp;value)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write the given array as with the proper array type encoding to the given buffer.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.UnsignedLong%5B%5D)" class="member-name-link">writeArray</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="../types/UnsignedLong.html" title="class in org.apache.qpid.protonj2.types">UnsignedLong</a>[]&nbsp;value)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write the given array as with the proper array type encoding to the given buffer.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.UnsignedShort%5B%5D)" class="member-name-link">writeArray</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="../types/UnsignedShort.html" title="class in org.apache.qpid.protonj2.types">UnsignedShort</a>[]&nbsp;value)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write the given array as with the proper array type encoding to the given buffer.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeBinary(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,byte%5B%5D)" class="member-name-link">writeBinary</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 byte[]&nbsp;value)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Writes the contents of the given <code>byte</code> value into the provided <a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer"><code>ProtonBuffer</code></a>
 instance as an AMQP Binary type.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeBinary(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.buffer.ProtonBuffer)" class="member-name-link">writeBinary</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;value)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Writes the contents of the given <a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer"><code>ProtonBuffer</code></a> value into the provided <a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer"><code>ProtonBuffer</code></a>
 instance as an AMQP Binary type.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeBinary(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.Binary)" class="member-name-link">writeBinary</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="../types/Binary.html" title="class in org.apache.qpid.protonj2.types">Binary</a>&nbsp;value)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Writes the contents of the given <a href="../types/Binary.html" title="class in org.apache.qpid.protonj2.types"><code>Binary</code></a> value into the provided <a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer"><code>ProtonBuffer</code></a>
 instance as an AMQP Binary type.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeBoolean(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,boolean)" class="member-name-link">writeBoolean</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 boolean&nbsp;value)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link"><code>Boolean</code></a> type encoding to the given buffer.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeBoolean(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.lang.Boolean)" class="member-name-link">writeBoolean</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&nbsp;value)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link"><code>Boolean</code></a> type encoding to the given buffer.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeByte(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,byte)" class="member-name-link">writeByte</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 byte&nbsp;value)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Byte.html" title="class or interface in java.lang" class="external-link"><code>Byte</code></a> type encoding to the given buffer.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeByte(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.lang.Byte)" class="member-name-link">writeByte</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Byte.html" title="class or interface in java.lang" class="external-link">Byte</a>&nbsp;value)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Byte.html" title="class or interface in java.lang" class="external-link"><code>Byte</code></a> type encoding to the given buffer.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeCharacter(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,char)" class="member-name-link">writeCharacter</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 char&nbsp;value)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Character.html" title="class or interface in java.lang" class="external-link"><code>Character</code></a> type encoding to the given buffer.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeCharacter(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.lang.Character)" class="member-name-link">writeCharacter</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Character.html" title="class or interface in java.lang" class="external-link">Character</a>&nbsp;value)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Character.html" title="class or interface in java.lang" class="external-link"><code>Character</code></a> type encoding to the given buffer.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeDecimal128(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.Decimal128)" class="member-name-link">writeDecimal128</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="../types/Decimal128.html" title="class in org.apache.qpid.protonj2.types">Decimal128</a>&nbsp;value)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write a <a href="../types/Decimal128.html" title="class in org.apache.qpid.protonj2.types"><code>Decimal128</code></a> type encoding to the given buffer.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeDecimal32(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.Decimal32)" class="member-name-link">writeDecimal32</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="../types/Decimal32.html" title="class in org.apache.qpid.protonj2.types">Decimal32</a>&nbsp;value)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write a <a href="../types/Decimal32.html" title="class in org.apache.qpid.protonj2.types"><code>Decimal32</code></a> type encoding to the given buffer.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeDecimal64(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.Decimal64)" class="member-name-link">writeDecimal64</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="../types/Decimal64.html" title="class in org.apache.qpid.protonj2.types">Decimal64</a>&nbsp;value)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write a <a href="../types/Decimal64.html" title="class in org.apache.qpid.protonj2.types"><code>Decimal64</code></a> type encoding to the given buffer.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeDeliveryTag(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.DeliveryTag)" class="member-name-link">writeDeliveryTag</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="../types/DeliveryTag.html" title="interface in org.apache.qpid.protonj2.types">DeliveryTag</a>&nbsp;value)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Writes the contents of the given <a href="../types/DeliveryTag.html" title="interface in org.apache.qpid.protonj2.types"><code>DeliveryTag</code></a> value into the provided <a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer"><code>ProtonBuffer</code></a>
 instance as an AMQP Binary type.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeDescribedType(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.DescribedType)" class="member-name-link">writeDescribedType</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="../types/DescribedType.html" title="interface in org.apache.qpid.protonj2.types">DescribedType</a>&nbsp;value)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write a <a href="../types/DescribedType.html" title="interface in org.apache.qpid.protonj2.types"><code>DescribedType</code></a> type encoding to the given buffer.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeDouble(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,double)" class="member-name-link">writeDouble</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 double&nbsp;value)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Double.html" title="class or interface in java.lang" class="external-link"><code>Double</code></a> type encoding to the given buffer.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeDouble(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.lang.Double)" class="member-name-link">writeDouble</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Double.html" title="class or interface in java.lang" class="external-link">Double</a>&nbsp;value)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Double.html" title="class or interface in java.lang" class="external-link"><code>Double</code></a> type encoding to the given buffer.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeFloat(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,float)" class="member-name-link">writeFloat</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 float&nbsp;value)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Float.html" title="class or interface in java.lang" class="external-link"><code>Float</code></a> type encoding to the given buffer.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeFloat(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.lang.Float)" class="member-name-link">writeFloat</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Float.html" title="class or interface in java.lang" class="external-link">Float</a>&nbsp;value)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Float.html" title="class or interface in java.lang" class="external-link"><code>Float</code></a> type encoding to the given buffer.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeInteger(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,int)" class="member-name-link">writeInteger</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 int&nbsp;value)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link"><code>Integer</code></a> type encoding to the given buffer.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeInteger(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.lang.Integer)" class="member-name-link">writeInteger</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;value)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link"><code>Integer</code></a> type encoding to the given buffer.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>&lt;T&gt;&nbsp;void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeList(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.util.List)" class="member-name-link">writeList</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;T&gt;&nbsp;value)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link"><code>List</code></a> type encoding to the given buffer.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeLong(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,long)" class="member-name-link">writeLong</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 long&nbsp;value)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link"><code>Long</code></a> type encoding to the given buffer.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeLong(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.lang.Long)" class="member-name-link">writeLong</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a>&nbsp;value)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link"><code>Long</code></a> type encoding to the given buffer.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>&lt;K,<wbr>
V&gt;&nbsp;void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeMap(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.util.Map)" class="member-name-link">writeMap</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;K,<wbr>V&gt;&nbsp;value)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write 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> type encoding to the given buffer.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeNull(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState)" class="member-name-link">writeNull</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write a Null type encoding to the given buffer.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeObject(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.lang.Object)" class="member-name-link">writeObject</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&nbsp;value)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write the proper type encoding for the provided <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link"><code>Object</code></a> to the given buffer if an <a href="TypeEncoder.html" title="interface in org.apache.qpid.protonj2.codec"><code>TypeEncoder</code></a>
 can be found for it in the collection of registered type encoders..</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeShort(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,short)" class="member-name-link">writeShort</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 short&nbsp;value)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Short.html" title="class or interface in java.lang" class="external-link"><code>Short</code></a> type encoding to the given buffer.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeShort(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.lang.Short)" class="member-name-link">writeShort</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Short.html" title="class or interface in java.lang" class="external-link">Short</a>&nbsp;value)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Short.html" title="class or interface in java.lang" class="external-link"><code>Short</code></a> type encoding to the given buffer.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeString(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.lang.String)" class="member-name-link">writeString</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <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;value)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write a <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"><code>String</code></a> type encoding to the given buffer.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeSymbol(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.lang.String)" class="member-name-link">writeSymbol</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <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;value)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write a <a href="../types/Symbol.html" title="class in org.apache.qpid.protonj2.types"><code>Symbol</code></a> type encoding to the given buffer.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeSymbol(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.Symbol)" class="member-name-link">writeSymbol</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="../types/Symbol.html" title="class in org.apache.qpid.protonj2.types">Symbol</a>&nbsp;value)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write a <a href="../types/Symbol.html" title="class in org.apache.qpid.protonj2.types"><code>Symbol</code></a> type encoding to the given buffer.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeTimestamp(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,long)" class="member-name-link">writeTimestamp</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 long&nbsp;value)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write a Time stamp type encoding to the given buffer.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeTimestamp(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.util.Date)" class="member-name-link">writeTimestamp</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Date.html" title="class or interface in java.util" class="external-link">Date</a>&nbsp;value)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write a Time stamp type encoding to the given buffer.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeUnsignedByte(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,byte)" class="member-name-link">writeUnsignedByte</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 byte&nbsp;value)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write an <a href="../types/UnsignedByte.html" title="class in org.apache.qpid.protonj2.types"><code>UnsignedByte</code></a> type encoding to the given buffer.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeUnsignedByte(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.UnsignedByte)" class="member-name-link">writeUnsignedByte</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="../types/UnsignedByte.html" title="class in org.apache.qpid.protonj2.types">UnsignedByte</a>&nbsp;value)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write an <a href="../types/UnsignedByte.html" title="class in org.apache.qpid.protonj2.types"><code>UnsignedByte</code></a> type encoding to the given buffer.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeUnsignedInteger(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,byte)" class="member-name-link">writeUnsignedInteger</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 byte&nbsp;value)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write a <a href="../types/UnsignedInteger.html" title="class in org.apache.qpid.protonj2.types"><code>UnsignedInteger</code></a> type encoding to the given buffer.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeUnsignedInteger(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,int)" class="member-name-link">writeUnsignedInteger</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 int&nbsp;value)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write a <a href="../types/UnsignedInteger.html" title="class in org.apache.qpid.protonj2.types"><code>UnsignedInteger</code></a> type encoding to the given buffer.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeUnsignedInteger(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,long)" class="member-name-link">writeUnsignedInteger</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 long&nbsp;value)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write a <a href="../types/UnsignedInteger.html" title="class in org.apache.qpid.protonj2.types"><code>UnsignedInteger</code></a> type encoding to the given buffer using the provided value with
 appropriate range checks to ensure invalid input is not accepted.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeUnsignedInteger(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.UnsignedInteger)" class="member-name-link">writeUnsignedInteger</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="../types/UnsignedInteger.html" title="class in org.apache.qpid.protonj2.types">UnsignedInteger</a>&nbsp;value)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write a <a href="../types/UnsignedInteger.html" title="class in org.apache.qpid.protonj2.types"><code>UnsignedInteger</code></a> type encoding to the given buffer.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeUnsignedLong(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,byte)" class="member-name-link">writeUnsignedLong</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 byte&nbsp;value)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write a <a href="../types/UnsignedLong.html" title="class in org.apache.qpid.protonj2.types"><code>UnsignedLong</code></a> type encoding to the given buffer.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeUnsignedLong(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,long)" class="member-name-link">writeUnsignedLong</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 long&nbsp;value)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write a <a href="../types/UnsignedLong.html" title="class in org.apache.qpid.protonj2.types"><code>UnsignedLong</code></a> type encoding to the given buffer.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeUnsignedLong(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.UnsignedLong)" class="member-name-link">writeUnsignedLong</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="../types/UnsignedLong.html" title="class in org.apache.qpid.protonj2.types">UnsignedLong</a>&nbsp;value)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write a <a href="../types/UnsignedLong.html" title="class in org.apache.qpid.protonj2.types"><code>UnsignedLong</code></a> type encoding to the given buffer.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeUnsignedShort(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,int)" class="member-name-link">writeUnsignedShort</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 int&nbsp;value)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write a <a href="../types/UnsignedShort.html" title="class in org.apache.qpid.protonj2.types"><code>UnsignedShort</code></a> type encoding to the given buffer using the provided value with
 appropriate range checks to ensure invalid input is not accepted.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeUnsignedShort(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,short)" class="member-name-link">writeUnsignedShort</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 short&nbsp;value)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write a <a href="../types/UnsignedShort.html" title="class in org.apache.qpid.protonj2.types"><code>UnsignedShort</code></a> type encoding to the given buffer.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeUnsignedShort(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.UnsignedShort)" class="member-name-link">writeUnsignedShort</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="../types/UnsignedShort.html" title="class in org.apache.qpid.protonj2.types">UnsignedShort</a>&nbsp;value)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write a <a href="../types/UnsignedShort.html" title="class in org.apache.qpid.protonj2.types"><code>UnsignedShort</code></a> type encoding to the given buffer.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#writeUUID(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.util.UUID)" class="member-name-link">writeUUID</a><wbr>(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/UUID.html" title="class or interface in java.util" class="external-link">UUID</a>&nbsp;value)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Write a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/UUID.html" title="class or interface in java.util" class="external-link"><code>UUID</code></a> type encoding to the given buffer.</div>
</div>
</div>
</div>
</div>
</section>
</li>
</ul>
</section>
<section class="details">
<ul class="details-list">
<!-- ============ METHOD DETAIL ========== -->
<li>
<section class="method-details" id="method-detail">
<h2>Method Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="newEncoderState()">
<h3>newEncoderState</h3>
<div class="member-signature"><span class="return-type"><a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a></span>&nbsp;<span class="element-name">newEncoderState</span>()</div>
<div class="block">Creates a new <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> instance that can be used when interacting with the
 Encoder.  For encoding that occurs on more than one thread while sharing a single
 <a href="Encoder.html" title="interface in org.apache.qpid.protonj2.codec"><code>Encoder</code></a> instance a different state object per thread is required as the
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> object can retain some state information during the encode process
 that could be corrupted if more than one thread were to share a single instance.

 For single threaded encoding work the <a href="Encoder.html" title="interface in org.apache.qpid.protonj2.codec"><code>Encoder</code></a> offers a utility
 cached <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> API that will return the same instance on each call which can
 reduce allocation overhead and make using the <a href="Encoder.html" title="interface in org.apache.qpid.protonj2.codec"><code>Encoder</code></a> simpler.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>a newly constructed <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getCachedEncoderState()">
<h3>getCachedEncoderState</h3>
<div class="member-signature"><span class="return-type"><a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a></span>&nbsp;<span class="element-name">getCachedEncoderState</span>()</div>
<div class="block">Return a singleton <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> instance that is meant to be shared within single threaded
 encoder interactions.  If more than one thread makes use of this cache <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> the
 results of any encoding done using this state object is not guaranteed to be correct.  The returned
 instance will have its reset method called to ensure that any previously stored state data is cleared
 before the next use.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>a cached <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> linked to this Encoder instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeNull(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState)">
<h3>writeNull</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeNull</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state)</span>
        throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write a Null type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeBoolean(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,boolean)">
<h3>writeBoolean</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeBoolean</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 boolean&nbsp;value)</span>
           throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link"><code>Boolean</code></a> type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeBoolean(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.lang.Boolean)">
<h3>writeBoolean</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeBoolean</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&nbsp;value)</span>
           throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link"><code>Boolean</code></a> type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeUnsignedByte(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.UnsignedByte)">
<h3>writeUnsignedByte</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeUnsignedByte</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="../types/UnsignedByte.html" title="class in org.apache.qpid.protonj2.types">UnsignedByte</a>&nbsp;value)</span>
                throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write an <a href="../types/UnsignedByte.html" title="class in org.apache.qpid.protonj2.types"><code>UnsignedByte</code></a> type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeUnsignedByte(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,byte)">
<h3>writeUnsignedByte</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeUnsignedByte</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 byte&nbsp;value)</span>
                throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write an <a href="../types/UnsignedByte.html" title="class in org.apache.qpid.protonj2.types"><code>UnsignedByte</code></a> type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeUnsignedShort(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.UnsignedShort)">
<h3>writeUnsignedShort</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeUnsignedShort</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="../types/UnsignedShort.html" title="class in org.apache.qpid.protonj2.types">UnsignedShort</a>&nbsp;value)</span>
                 throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write a <a href="../types/UnsignedShort.html" title="class in org.apache.qpid.protonj2.types"><code>UnsignedShort</code></a> type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeUnsignedShort(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,short)">
<h3>writeUnsignedShort</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeUnsignedShort</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 short&nbsp;value)</span>
                 throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write a <a href="../types/UnsignedShort.html" title="class in org.apache.qpid.protonj2.types"><code>UnsignedShort</code></a> type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeUnsignedShort(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,int)">
<h3>writeUnsignedShort</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeUnsignedShort</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 int&nbsp;value)</span>
                 throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write a <a href="../types/UnsignedShort.html" title="class in org.apache.qpid.protonj2.types"><code>UnsignedShort</code></a> type encoding to the given buffer using the provided value with
 appropriate range checks to ensure invalid input is not accepted.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeUnsignedInteger(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.UnsignedInteger)">
<h3>writeUnsignedInteger</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeUnsignedInteger</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="../types/UnsignedInteger.html" title="class in org.apache.qpid.protonj2.types">UnsignedInteger</a>&nbsp;value)</span>
                   throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write a <a href="../types/UnsignedInteger.html" title="class in org.apache.qpid.protonj2.types"><code>UnsignedInteger</code></a> type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeUnsignedInteger(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,byte)">
<h3>writeUnsignedInteger</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeUnsignedInteger</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 byte&nbsp;value)</span>
                   throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write a <a href="../types/UnsignedInteger.html" title="class in org.apache.qpid.protonj2.types"><code>UnsignedInteger</code></a> type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeUnsignedInteger(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,int)">
<h3>writeUnsignedInteger</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeUnsignedInteger</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 int&nbsp;value)</span>
                   throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write a <a href="../types/UnsignedInteger.html" title="class in org.apache.qpid.protonj2.types"><code>UnsignedInteger</code></a> type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeUnsignedInteger(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,long)">
<h3>writeUnsignedInteger</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeUnsignedInteger</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 long&nbsp;value)</span>
                   throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write a <a href="../types/UnsignedInteger.html" title="class in org.apache.qpid.protonj2.types"><code>UnsignedInteger</code></a> type encoding to the given buffer using the provided value with
 appropriate range checks to ensure invalid input is not accepted.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeUnsignedLong(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.UnsignedLong)">
<h3>writeUnsignedLong</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeUnsignedLong</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="../types/UnsignedLong.html" title="class in org.apache.qpid.protonj2.types">UnsignedLong</a>&nbsp;value)</span>
                throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write a <a href="../types/UnsignedLong.html" title="class in org.apache.qpid.protonj2.types"><code>UnsignedLong</code></a> type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeUnsignedLong(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,byte)">
<h3>writeUnsignedLong</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeUnsignedLong</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 byte&nbsp;value)</span>
                throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write a <a href="../types/UnsignedLong.html" title="class in org.apache.qpid.protonj2.types"><code>UnsignedLong</code></a> type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeUnsignedLong(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,long)">
<h3>writeUnsignedLong</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeUnsignedLong</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 long&nbsp;value)</span>
                throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write a <a href="../types/UnsignedLong.html" title="class in org.apache.qpid.protonj2.types"><code>UnsignedLong</code></a> type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeByte(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,byte)">
<h3>writeByte</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeByte</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 byte&nbsp;value)</span>
        throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Byte.html" title="class or interface in java.lang" class="external-link"><code>Byte</code></a> type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeByte(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.lang.Byte)">
<h3>writeByte</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeByte</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Byte.html" title="class or interface in java.lang" class="external-link">Byte</a>&nbsp;value)</span>
        throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Byte.html" title="class or interface in java.lang" class="external-link"><code>Byte</code></a> type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeShort(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,short)">
<h3>writeShort</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeShort</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 short&nbsp;value)</span>
         throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Short.html" title="class or interface in java.lang" class="external-link"><code>Short</code></a> type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeShort(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.lang.Short)">
<h3>writeShort</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeShort</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Short.html" title="class or interface in java.lang" class="external-link">Short</a>&nbsp;value)</span>
         throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Short.html" title="class or interface in java.lang" class="external-link"><code>Short</code></a> type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeInteger(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,int)">
<h3>writeInteger</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeInteger</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 int&nbsp;value)</span>
           throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link"><code>Integer</code></a> type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeInteger(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.lang.Integer)">
<h3>writeInteger</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeInteger</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;value)</span>
           throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link"><code>Integer</code></a> type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeLong(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,long)">
<h3>writeLong</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeLong</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 long&nbsp;value)</span>
        throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link"><code>Long</code></a> type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeLong(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.lang.Long)">
<h3>writeLong</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeLong</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a>&nbsp;value)</span>
        throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link"><code>Long</code></a> type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeFloat(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,float)">
<h3>writeFloat</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeFloat</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 float&nbsp;value)</span>
         throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Float.html" title="class or interface in java.lang" class="external-link"><code>Float</code></a> type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeFloat(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.lang.Float)">
<h3>writeFloat</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeFloat</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Float.html" title="class or interface in java.lang" class="external-link">Float</a>&nbsp;value)</span>
         throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Float.html" title="class or interface in java.lang" class="external-link"><code>Float</code></a> type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeDouble(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,double)">
<h3>writeDouble</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeDouble</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 double&nbsp;value)</span>
          throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Double.html" title="class or interface in java.lang" class="external-link"><code>Double</code></a> type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeDouble(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.lang.Double)">
<h3>writeDouble</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeDouble</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Double.html" title="class or interface in java.lang" class="external-link">Double</a>&nbsp;value)</span>
          throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Double.html" title="class or interface in java.lang" class="external-link"><code>Double</code></a> type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeDecimal32(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.Decimal32)">
<h3>writeDecimal32</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeDecimal32</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="../types/Decimal32.html" title="class in org.apache.qpid.protonj2.types">Decimal32</a>&nbsp;value)</span>
             throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write a <a href="../types/Decimal32.html" title="class in org.apache.qpid.protonj2.types"><code>Decimal32</code></a> type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeDecimal64(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.Decimal64)">
<h3>writeDecimal64</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeDecimal64</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="../types/Decimal64.html" title="class in org.apache.qpid.protonj2.types">Decimal64</a>&nbsp;value)</span>
             throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write a <a href="../types/Decimal64.html" title="class in org.apache.qpid.protonj2.types"><code>Decimal64</code></a> type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeDecimal128(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.Decimal128)">
<h3>writeDecimal128</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeDecimal128</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="../types/Decimal128.html" title="class in org.apache.qpid.protonj2.types">Decimal128</a>&nbsp;value)</span>
              throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write a <a href="../types/Decimal128.html" title="class in org.apache.qpid.protonj2.types"><code>Decimal128</code></a> type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeCharacter(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,char)">
<h3>writeCharacter</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeCharacter</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 char&nbsp;value)</span>
             throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Character.html" title="class or interface in java.lang" class="external-link"><code>Character</code></a> type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeCharacter(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.lang.Character)">
<h3>writeCharacter</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeCharacter</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Character.html" title="class or interface in java.lang" class="external-link">Character</a>&nbsp;value)</span>
             throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Character.html" title="class or interface in java.lang" class="external-link"><code>Character</code></a> type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeTimestamp(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,long)">
<h3>writeTimestamp</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeTimestamp</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 long&nbsp;value)</span>
             throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write a Time stamp type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeTimestamp(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.util.Date)">
<h3>writeTimestamp</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeTimestamp</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Date.html" title="class or interface in java.util" class="external-link">Date</a>&nbsp;value)</span>
             throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write a Time stamp type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeUUID(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.util.UUID)">
<h3>writeUUID</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeUUID</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/UUID.html" title="class or interface in java.util" class="external-link">UUID</a>&nbsp;value)</span>
        throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/UUID.html" title="class or interface in java.util" class="external-link"><code>UUID</code></a> type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeBinary(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.Binary)">
<h3>writeBinary</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeBinary</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="../types/Binary.html" title="class in org.apache.qpid.protonj2.types">Binary</a>&nbsp;value)</span>
          throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Writes the contents of the given <a href="../types/Binary.html" title="class in org.apache.qpid.protonj2.types"><code>Binary</code></a> value into the provided <a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer"><code>ProtonBuffer</code></a>
 instance as an AMQP Binary type.
 <p>
 If the provided value to write is null an AMQP null type is encoded into the target buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeBinary(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.buffer.ProtonBuffer)">
<h3>writeBinary</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeBinary</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;value)</span>
          throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Writes the contents of the given <a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer"><code>ProtonBuffer</code></a> value into the provided <a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer"><code>ProtonBuffer</code></a>
 instance as an AMQP Binary type.  This method does not modify the read index of the value given such
 that is can be read later or written again without needing to reset the read index manually.
 <p>
 If the provided value to write is null an AMQP null type is encoded into the target buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - the target buffer where the binary value is to be encoded</dd>
<dd><code>state</code> - the <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> instance that manages the calling threads state tracking.</dd>
<dd><code>value</code> - the <a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer"><code>ProtonBuffer</code></a> value to be encoded as an AMQP binary instance.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs while performing the encode</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeBinary(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,byte[])">
<h3>writeBinary</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeBinary</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 byte[]&nbsp;value)</span>
          throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Writes the contents of the given <code>byte</code> value into the provided <a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer"><code>ProtonBuffer</code></a>
 instance as an AMQP Binary type.
 <p>
 If the provided value to write is null an AMQP null type is encoded into the target buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - the target buffer where the binary value is to be encoded</dd>
<dd><code>state</code> - the <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> instance that manages the calling threads state tracking.</dd>
<dd><code>value</code> - the <a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer"><code>ProtonBuffer</code></a> value to be encoded as an AMQP binary instance.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs while performing the encode</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeString(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.lang.String)">
<h3>writeString</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeString</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <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;value)</span>
          throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write a <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"><code>String</code></a> type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeSymbol(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.Symbol)">
<h3>writeSymbol</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeSymbol</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="../types/Symbol.html" title="class in org.apache.qpid.protonj2.types">Symbol</a>&nbsp;value)</span>
          throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write a <a href="../types/Symbol.html" title="class in org.apache.qpid.protonj2.types"><code>Symbol</code></a> type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeSymbol(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.lang.String)">
<h3>writeSymbol</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeSymbol</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <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;value)</span>
          throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write a <a href="../types/Symbol.html" title="class in org.apache.qpid.protonj2.types"><code>Symbol</code></a> type encoding to the given buffer.  The provided <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"><code>String</code></a> instance should
 contain only ASCII characters and the encoder should throw an <a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec"><code>EncodeException</code></a> if a non-ASCII
 character is encountered.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeList(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.util.List)">
<h3>writeList</h3>
<div class="member-signature"><span class="type-parameters">&lt;T&gt;</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">writeList</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;T&gt;&nbsp;value)</span>
            throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link"><code>List</code></a> type encoding to the given buffer.</div>
<dl class="notes">
<dt>Type Parameters:</dt>
<dd><code>T</code> - The type that comprises the <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link"><code>List</code></a> entries.</dd>
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeMap(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.util.Map)">
<h3>writeMap</h3>
<div class="member-signature"><span class="type-parameters">&lt;K,<wbr>
V&gt;</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">writeMap</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;K,<wbr>V&gt;&nbsp;value)</span>
             throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write 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> type encoding to the given buffer.</div>
<dl class="notes">
<dt>Type Parameters:</dt>
<dd><code>K</code> - the type that comprises the <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link"><code>Map</code></a> keys.</dd>
<dd><code>V</code> - the type that comprises the <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link"><code>Map</code></a> values.</dd>
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeDeliveryTag(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.DeliveryTag)">
<h3>writeDeliveryTag</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeDeliveryTag</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="../types/DeliveryTag.html" title="interface in org.apache.qpid.protonj2.types">DeliveryTag</a>&nbsp;value)</span>
               throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Writes the contents of the given <a href="../types/DeliveryTag.html" title="interface in org.apache.qpid.protonj2.types"><code>DeliveryTag</code></a> value into the provided <a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer"><code>ProtonBuffer</code></a>
 instance as an AMQP Binary type.
 <p>
 If the provided value to write is null an AMQP null type is encoded into the target buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - the target buffer where the binary value is to be encoded</dd>
<dd><code>state</code> - the <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> instance that manages the calling threads state tracking.</dd>
<dd><code>value</code> - the <a href="../types/DeliveryTag.html" title="interface in org.apache.qpid.protonj2.types"><code>DeliveryTag</code></a> value to be encoded as an AMQP binary instance.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs while performing the encode</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeDescribedType(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.DescribedType)">
<h3>writeDescribedType</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeDescribedType</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="../types/DescribedType.html" title="interface in org.apache.qpid.protonj2.types">DescribedType</a>&nbsp;value)</span>
                 throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write a <a href="../types/DescribedType.html" title="interface in org.apache.qpid.protonj2.types"><code>DescribedType</code></a> type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeObject(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.lang.Object)">
<h3>writeObject</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeObject</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&nbsp;value)</span>
          throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write the proper type encoding for the provided <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link"><code>Object</code></a> to the given buffer if an <a href="TypeEncoder.html" title="interface in org.apache.qpid.protonj2.codec"><code>TypeEncoder</code></a>
 can be found for it in the collection of registered type encoders..</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,boolean[])">
<h3>writeArray</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeArray</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 boolean[]&nbsp;value)</span>
         throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write the given array as with the proper array type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,byte[])">
<h3>writeArray</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeArray</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 byte[]&nbsp;value)</span>
         throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write the given array as with the proper array type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,short[])">
<h3>writeArray</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeArray</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 short[]&nbsp;value)</span>
         throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write the given array as with the proper array type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,int[])">
<h3>writeArray</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeArray</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 int[]&nbsp;value)</span>
         throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write the given array as with the proper array type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,long[])">
<h3>writeArray</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeArray</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 long[]&nbsp;value)</span>
         throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write the given array as with the proper array type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,float[])">
<h3>writeArray</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeArray</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 float[]&nbsp;value)</span>
         throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write the given array as with the proper array type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,double[])">
<h3>writeArray</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeArray</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 double[]&nbsp;value)</span>
         throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write the given array as with the proper array type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,char[])">
<h3>writeArray</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeArray</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 char[]&nbsp;value)</span>
         throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write the given array as with the proper array type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.lang.Object[])">
<h3>writeArray</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeArray</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>[]&nbsp;value)</span>
         throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write the given array as with the proper array type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.Decimal32[])">
<h3>writeArray</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeArray</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="../types/Decimal32.html" title="class in org.apache.qpid.protonj2.types">Decimal32</a>[]&nbsp;value)</span>
         throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write the given array as with the proper array type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.Decimal64[])">
<h3>writeArray</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeArray</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="../types/Decimal64.html" title="class in org.apache.qpid.protonj2.types">Decimal64</a>[]&nbsp;value)</span>
         throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write the given array as with the proper array type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.Decimal128[])">
<h3>writeArray</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeArray</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="../types/Decimal128.html" title="class in org.apache.qpid.protonj2.types">Decimal128</a>[]&nbsp;value)</span>
         throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write the given array as with the proper array type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.Symbol[])">
<h3>writeArray</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeArray</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="../types/Symbol.html" title="class in org.apache.qpid.protonj2.types">Symbol</a>[]&nbsp;value)</span>
         throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write the given array as with the proper array type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.UnsignedByte[])">
<h3>writeArray</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeArray</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="../types/UnsignedByte.html" title="class in org.apache.qpid.protonj2.types">UnsignedByte</a>[]&nbsp;value)</span>
         throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write the given array as with the proper array type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.UnsignedShort[])">
<h3>writeArray</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeArray</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="../types/UnsignedShort.html" title="class in org.apache.qpid.protonj2.types">UnsignedShort</a>[]&nbsp;value)</span>
         throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write the given array as with the proper array type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.UnsignedInteger[])">
<h3>writeArray</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeArray</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="../types/UnsignedInteger.html" title="class in org.apache.qpid.protonj2.types">UnsignedInteger</a>[]&nbsp;value)</span>
         throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write the given array as with the proper array type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.UnsignedLong[])">
<h3>writeArray</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeArray</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="../types/UnsignedLong.html" title="class in org.apache.qpid.protonj2.types">UnsignedLong</a>[]&nbsp;value)</span>
         throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write the given array as with the proper array type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.util.UUID[])">
<h3>writeArray</h3>
<div class="member-signature"><span class="return-type">void</span>&nbsp;<span class="element-name">writeArray</span><wbr><span class="parameters">(<a href="../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;state,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/UUID.html" title="class or interface in java.util" class="external-link">UUID</a>[]&nbsp;value)</span>
         throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Write the given array as with the proper array type encoding to the given buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer where the write operation is targeted</dd>
<dd><code>state</code> - The <a href="EncoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>EncoderState</code></a> to use for any intermediate encoding work.</dd>
<dd><code>value</code> - The value to be encoded into the provided buffer.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs during the encode operation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="registerDescribedTypeEncoder(org.apache.qpid.protonj2.codec.DescribedTypeEncoder)">
<h3>registerDescribedTypeEncoder</h3>
<div class="member-signature"><span class="type-parameters">&lt;V&gt;</span>&nbsp;<span class="return-type"><a href="Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></span>&nbsp;<span class="element-name">registerDescribedTypeEncoder</span><wbr><span class="parameters">(<a href="DescribedTypeEncoder.html" title="interface in org.apache.qpid.protonj2.codec">DescribedTypeEncoder</a>&lt;V&gt;&nbsp;encoder)</span>
                                  throws <span class="exceptions"><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></span></div>
<div class="block">Register a <a href="DescribedTypeEncoder.html" title="interface in org.apache.qpid.protonj2.codec"><code>DescribedTypeEncoder</code></a> which can be used when writing custom types using this
 encoder.  When an Object write is performed the type encoder registry will be consulted in order
 to find the best match for the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link"><code>Object</code></a> instance.</div>
<dl class="notes">
<dt>Type Parameters:</dt>
<dd><code>V</code> - The type that the encoder handles.</dd>
<dt>Parameters:</dt>
<dd><code>encoder</code> - A new <a href="DescribedTypeEncoder.html" title="interface in org.apache.qpid.protonj2.codec"><code>DescribedTypeEncoder</code></a> that will be used when encoding its matching type.</dd>
<dt>Returns:</dt>
<dd>this <a href="Encoder.html" title="interface in org.apache.qpid.protonj2.codec"><code>Encoder</code></a> instance.</dd>
<dt>Throws:</dt>
<dd><code><a href="EncodeException.html" title="class in org.apache.qpid.protonj2.codec">EncodeException</a></code> - if an error occurs while adding the encoder to the registry.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getTypeEncoder(java.lang.Object)">
<h3>getTypeEncoder</h3>
<div class="member-signature"><span class="return-type"><a href="TypeEncoder.html" title="interface in org.apache.qpid.protonj2.codec">TypeEncoder</a>&lt;?&gt;</span>&nbsp;<span class="element-name">getTypeEncoder</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;value)</span></div>
<div class="block">Lookup a <a href="TypeEncoder.html" title="interface in org.apache.qpid.protonj2.codec"><code>TypeEncoder</code></a> that would be used to encode the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link"><code>Object</code></a>.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>value</code> - The value which should be used to resolve the <a href="TypeEncoder.html" title="interface in org.apache.qpid.protonj2.codec"><code>TypeEncoder</code></a> that encodes it.</dd>
<dt>Returns:</dt>
<dd>the matching <a href="TypeEncoder.html" title="interface in org.apache.qpid.protonj2.codec"><code>TypeEncoder</code></a> for the given value or null if no match found.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getTypeEncoder(java.lang.Class)">
<h3>getTypeEncoder</h3>
<div class="member-signature"><span class="return-type"><a href="TypeEncoder.html" title="interface in org.apache.qpid.protonj2.codec">TypeEncoder</a>&lt;?&gt;</span>&nbsp;<span class="element-name">getTypeEncoder</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Class.html" title="class or interface in java.lang" class="external-link">Class</a>&lt;?&gt;&nbsp;typeClass)</span></div>
<div class="block">Lookup a <a href="TypeEncoder.html" title="interface in org.apache.qpid.protonj2.codec"><code>TypeEncoder</code></a> that would be used to encode the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Class.html" title="class or interface in java.lang" class="external-link"><code>Class</code></a>.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>typeClass</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Class.html" title="class or interface in java.lang" class="external-link"><code>Class</code></a> which should be used to resolve the <a href="TypeEncoder.html" title="interface in org.apache.qpid.protonj2.codec"><code>TypeEncoder</code></a> that encodes it.</dd>
<dt>Returns:</dt>
<dd>the matching <a href="TypeEncoder.html" title="interface in org.apache.qpid.protonj2.codec"><code>TypeEncoder</code></a> for the given value or null if no match found.</dd>
</dl>
</section>
</li>
</ul>
</section>
</li>
</ul>
</section>
<!-- ========= END OF CLASS DATA ========= -->
</main>
<footer role="contentinfo">
<hr>
<p class="legal-copy"><small>Copyright &#169; 2024 <a href="https://www.apache.org/">The Apache Software Foundation</a>. All rights reserved.</small></p>
</footer>
</div>
</div>
</body>
</html>
