<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>ProtonEncoder (Qpid ProtonJ2 Parent 1.0.0-M18 API)</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<meta name="description" content="declaration: package: org.apache.qpid.protonj2.codec.encoders, class: ProtonEncoder">
<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/ProtonEncoder.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><a href="#constructor-summary">Constr</a>&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><a href="#constructor-detail">Constr</a>&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.encoders</a></div>
<h1 title="Class ProtonEncoder" class="title">Class ProtonEncoder</h1>
</div>
<div class="inheritance" title="Inheritance Tree"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">java.lang.Object</a>
<div class="inheritance">org.apache.qpid.protonj2.codec.encoders.ProtonEncoder</div>
</div>
<section class="class-description" id="class-description">
<dl class="notes">
<dt>All Implemented Interfaces:</dt>
<dd><code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></dd>
</dl>
<hr>
<div class="type-signature"><span class="modifiers">public final class </span><span class="element-name type-name-label">ProtonEncoder</span>
<span class="extends-implements">extends <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>
implements <a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></span></div>
<div class="block">The default AMQP Encoder implementation.</div>
</section>
<section class="summary">
<ul class="summary-list">
<!-- ======== CONSTRUCTOR SUMMARY ======== -->
<li>
<section class="constructor-summary" id="constructor-summary">
<h2>Constructor Summary</h2>
<div class="caption"><span>Constructors</span></div>
<div class="summary-table two-column-summary">
<div class="table-header col-first">Constructor</div>
<div class="table-header col-last">Description</div>
<div class="col-constructor-name even-row-color"><code><a href="#%3Cinit%3E()" class="member-name-link">ProtonEncoder</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
</div>
</section>
</li>
<!-- ========== 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-tab4" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab4', 3)" class="table-tab">Concrete Methods</button></div>
<div id="method-summary-table.tabpanel" role="tabpanel">
<div class="summary-table three-column-summary" aria-labelledby="method-summary-table-tab0">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Method</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ProtonEncoderState.html" title="class in org.apache.qpid.protonj2.codec.encoders">ProtonEncoderState</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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-tab4">
<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-tab4"><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-tab4"><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-tab4">
<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-tab4"><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-tab4"><code><a href="#getTypeEncoder(java.lang.Class,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/Class.html" title="class or interface in java.lang" class="external-link">Class</a>&lt;?&gt;&nbsp;typeClass,
 <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;instance)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Lookup a <a href="../TypeEncoder.html" title="interface in org.apache.qpid.protonj2.codec"><code>TypeEncoder</code></a> by first checking the given type <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> and then
 if none found to deduce a valid TypeEncoder from the <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> specified.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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-tab4"><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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ProtonEncoderState.html" title="class in org.apache.qpid.protonj2.codec.encoders">ProtonEncoderState</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#newEncoderState()" class="member-name-link">newEncoderState</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>&lt;V&gt;&nbsp;<a href="ProtonEncoder.html" title="class in org.apache.qpid.protonj2.codec.encoders">ProtonEncoder</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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-tab4"><code>&lt;T&gt;&nbsp;void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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-tab4"><code>&lt;K,<wbr>
V&gt;&nbsp;void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Write a Null 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-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<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>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-java.lang.Object">Methods inherited from class&nbsp;java.lang.<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></h3>
<code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#clone()" title="class or interface in java.lang" class="external-link">clone</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#equals(java.lang.Object)" title="class or interface in java.lang" class="external-link">equals</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#finalize()" title="class or interface in java.lang" class="external-link">finalize</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#getClass()" title="class or interface in java.lang" class="external-link">getClass</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#hashCode()" title="class or interface in java.lang" class="external-link">hashCode</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#notify()" title="class or interface in java.lang" class="external-link">notify</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#notifyAll()" title="class or interface in java.lang" class="external-link">notifyAll</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#toString()" title="class or interface in java.lang" class="external-link">toString</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#wait()" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#wait(long)" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#wait(long,int)" title="class or interface in java.lang" class="external-link">wait</a></code></div>
</section>
</li>
</ul>
</section>
<section class="details">
<ul class="details-list">
<!-- ========= CONSTRUCTOR DETAIL ======== -->
<li>
<section class="constructor-details" id="constructor-detail">
<h2>Constructor Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="&lt;init&gt;()">
<h3>ProtonEncoder</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="element-name">ProtonEncoder</span>()</div>
</section>
</li>
</ul>
</section>
</li>
<!-- ============ 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="modifiers">public</span>&nbsp;<span class="return-type"><a href="ProtonEncoderState.html" title="class in org.apache.qpid.protonj2.codec.encoders">ProtonEncoderState</a></span>&nbsp;<span class="element-name">newEncoderState</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#newEncoderState()">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#newEncoderState()">newEncoderState</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></dd>
<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="modifiers">public</span>&nbsp;<span class="return-type"><a href="ProtonEncoderState.html" title="class in org.apache.qpid.protonj2.codec.encoders">ProtonEncoderState</a></span>&nbsp;<span class="element-name">getCachedEncoderState</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#getCachedEncoderState()">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#getCachedEncoderState()">getCachedEncoderState</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></dd>
<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="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeNull(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState)">Encoder</a></code></span></div>
<div class="block">Write a Null type encoding to the given buffer.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeNull(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState)">writeNull</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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>
<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="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeBoolean(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,boolean)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeBoolean(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,boolean)">writeBoolean</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="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="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeBoolean(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.lang.Boolean)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeBoolean(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.lang.Boolean)">writeBoolean</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="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="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeUnsignedByte(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.UnsignedByte)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeUnsignedByte(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.UnsignedByte)">writeUnsignedByte</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="writeUnsignedByte(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,byte)">
<h3>writeUnsignedByte</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeUnsignedByte(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,byte)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeUnsignedByte(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,byte)">writeUnsignedByte</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="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="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeUnsignedShort(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.UnsignedShort)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeUnsignedShort(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.UnsignedShort)">writeUnsignedShort</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="writeUnsignedShort(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,short)">
<h3>writeUnsignedShort</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeUnsignedShort(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,short)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeUnsignedShort(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,short)">writeUnsignedShort</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="writeUnsignedShort(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,int)">
<h3>writeUnsignedShort</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeUnsignedShort(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,int)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeUnsignedShort(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,int)">writeUnsignedShort</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="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="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeUnsignedInteger(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.UnsignedInteger)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeUnsignedInteger(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.UnsignedInteger)">writeUnsignedInteger</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="writeUnsignedInteger(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,byte)">
<h3>writeUnsignedInteger</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeUnsignedInteger(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,byte)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeUnsignedInteger(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,byte)">writeUnsignedInteger</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="writeUnsignedInteger(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,int)">
<h3>writeUnsignedInteger</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeUnsignedInteger(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,int)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeUnsignedInteger(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,int)">writeUnsignedInteger</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="writeUnsignedInteger(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,long)">
<h3>writeUnsignedInteger</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeUnsignedInteger(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,long)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeUnsignedInteger(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,long)">writeUnsignedInteger</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="writeUnsignedLong(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,byte)">
<h3>writeUnsignedLong</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeUnsignedLong(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,byte)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeUnsignedLong(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,byte)">writeUnsignedLong</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="writeUnsignedLong(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,long)">
<h3>writeUnsignedLong</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeUnsignedLong(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,long)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeUnsignedLong(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,long)">writeUnsignedLong</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="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="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeUnsignedLong(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.UnsignedLong)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeUnsignedLong(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.UnsignedLong)">writeUnsignedLong</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="writeByte(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,byte)">
<h3>writeByte</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeByte(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,byte)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeByte(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,byte)">writeByte</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="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="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeByte(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.lang.Byte)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeByte(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.lang.Byte)">writeByte</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="writeShort(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,short)">
<h3>writeShort</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeShort(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,short)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeShort(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,short)">writeShort</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="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="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeShort(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.lang.Short)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeShort(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.lang.Short)">writeShort</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="writeInteger(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,int)">
<h3>writeInteger</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeInteger(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,int)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeInteger(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,int)">writeInteger</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="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="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeInteger(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.lang.Integer)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeInteger(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.lang.Integer)">writeInteger</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="writeLong(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,long)">
<h3>writeLong</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeLong(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,long)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeLong(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,long)">writeLong</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="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="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeLong(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.lang.Long)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeLong(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.lang.Long)">writeLong</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="writeFloat(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,float)">
<h3>writeFloat</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeFloat(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,float)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeFloat(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,float)">writeFloat</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="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="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeFloat(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.lang.Float)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeFloat(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.lang.Float)">writeFloat</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="writeDouble(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,double)">
<h3>writeDouble</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeDouble(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,double)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeDouble(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,double)">writeDouble</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="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="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeDouble(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.lang.Double)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeDouble(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.lang.Double)">writeDouble</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="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="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeDecimal32(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.Decimal32)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeDecimal32(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.Decimal32)">writeDecimal32</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="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="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeDecimal64(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.Decimal64)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeDecimal64(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.Decimal64)">writeDecimal64</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="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="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeDecimal128(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.Decimal128)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeDecimal128(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.Decimal128)">writeDecimal128</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="writeCharacter(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,char)">
<h3>writeCharacter</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeCharacter(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,char)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeCharacter(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,char)">writeCharacter</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="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="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeCharacter(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.lang.Character)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeCharacter(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.lang.Character)">writeCharacter</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="writeTimestamp(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,long)">
<h3>writeTimestamp</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeTimestamp(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,long)">Encoder</a></code></span></div>
<div class="block">Write a Time stamp type encoding to the given buffer.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeTimestamp(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,long)">writeTimestamp</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="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="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeTimestamp(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.util.Date)">Encoder</a></code></span></div>
<div class="block">Write a Time stamp type encoding to the given buffer.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeTimestamp(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.util.Date)">writeTimestamp</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="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="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeUUID(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.util.UUID)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeUUID(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.util.UUID)">writeUUID</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="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="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeBinary(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.Binary)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeBinary(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.Binary)">writeBinary</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="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="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeBinary(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.buffer.ProtonBuffer)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeBinary(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.buffer.ProtonBuffer)">writeBinary</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></dd>
<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="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeBinary(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,byte%5B%5D)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeBinary(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,byte%5B%5D)">writeBinary</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></dd>
<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="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="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeDeliveryTag(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.DeliveryTag)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeDeliveryTag(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.DeliveryTag)">writeDeliveryTag</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></dd>
<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="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="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeString(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.lang.String)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeString(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.lang.String)">writeString</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="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="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeSymbol(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.Symbol)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeSymbol(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.Symbol)">writeSymbol</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="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="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeSymbol(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.lang.String)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeSymbol(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.lang.String)">writeSymbol</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="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="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeList(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.util.List)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeList(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.util.List)">writeList</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></dd>
<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="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeMap(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.util.Map)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeMap(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.util.Map)">writeMap</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></dd>
<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="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="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeDescribedType(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.DescribedType)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeDescribedType(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.DescribedType)">writeDescribedType</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,boolean[])">
<h3>writeArray</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,boolean%5B%5D)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,boolean%5B%5D)">writeArray</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,byte[])">
<h3>writeArray</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,byte%5B%5D)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,byte%5B%5D)">writeArray</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,short[])">
<h3>writeArray</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,short%5B%5D)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,short%5B%5D)">writeArray</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,int[])">
<h3>writeArray</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,int%5B%5D)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,int%5B%5D)">writeArray</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,long[])">
<h3>writeArray</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,long%5B%5D)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,long%5B%5D)">writeArray</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,float[])">
<h3>writeArray</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,float%5B%5D)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,float%5B%5D)">writeArray</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,double[])">
<h3>writeArray</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,double%5B%5D)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,double%5B%5D)">writeArray</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,char[])">
<h3>writeArray</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,char%5B%5D)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,char%5B%5D)">writeArray</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="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="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.lang.Object%5B%5D)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.lang.Object%5B%5D)">writeArray</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="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="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.Decimal32%5B%5D)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.Decimal32%5B%5D)">writeArray</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="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="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.Decimal64%5B%5D)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.Decimal64%5B%5D)">writeArray</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="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="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.Decimal128%5B%5D)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.Decimal128%5B%5D)">writeArray</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="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="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.Symbol%5B%5D)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.Symbol%5B%5D)">writeArray</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="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="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.UnsignedByte%5B%5D)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.UnsignedByte%5B%5D)">writeArray</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="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="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.UnsignedShort%5B%5D)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.UnsignedShort%5B%5D)">writeArray</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="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="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.UnsignedInteger%5B%5D)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.UnsignedInteger%5B%5D)">writeArray</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="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="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.UnsignedLong%5B%5D)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.types.UnsignedLong%5B%5D)">writeArray</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="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="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.util.UUID%5B%5D)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeArray(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.util.UUID%5B%5D)">writeArray</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="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="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#writeObject(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.lang.Object)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#writeObject(org.apache.qpid.protonj2.buffer.ProtonBuffer,org.apache.qpid.protonj2.codec.EncoderState,java.lang.Object)">writeObject</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></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="registerDescribedTypeEncoder(org.apache.qpid.protonj2.codec.DescribedTypeEncoder)">
<h3>registerDescribedTypeEncoder</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="type-parameters">&lt;V&gt;</span>&nbsp;<span class="return-type"><a href="ProtonEncoder.html" title="class in org.apache.qpid.protonj2.codec.encoders">ProtonEncoder</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></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#registerDescribedTypeEncoder(org.apache.qpid.protonj2.codec.DescribedTypeEncoder)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#registerDescribedTypeEncoder(org.apache.qpid.protonj2.codec.DescribedTypeEncoder)">registerDescribedTypeEncoder</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></dd>
<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>
</dl>
</section>
</li>
<li>
<section class="detail" id="getTypeEncoder(java.lang.Object)">
<h3>getTypeEncoder</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#getTypeEncoder(java.lang.Object)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#getTypeEncoder(java.lang.Object)">getTypeEncoder</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></dd>
<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="modifiers">public</span>&nbsp;<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"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../Encoder.html#getTypeEncoder(java.lang.Class)">Encoder</a></code></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>Specified by:</dt>
<dd><code><a href="../Encoder.html#getTypeEncoder(java.lang.Class)">getTypeEncoder</a></code>&nbsp;in interface&nbsp;<code><a href="../Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a></code></dd>
<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>
<li>
<section class="detail" id="getTypeEncoder(java.lang.Class,java.lang.Object)">
<h3>getTypeEncoder</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<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,
 <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;instance)</span></div>
<div class="block">Lookup a <a href="../TypeEncoder.html" title="interface in org.apache.qpid.protonj2.codec"><code>TypeEncoder</code></a> by first checking the given type <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> and then
 if none found to deduce a valid TypeEncoder from the <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> specified.</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> for which a type specific encoder is requested.</dd>
<dd><code>instance</code> - An <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 to use as a fall back if no encoder found for 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></dd>
<dt>Returns:</dt>
<dd>a <a href="../TypeEncoder.html" title="interface in org.apache.qpid.protonj2.codec"><code>TypeEncoder</code></a> if a match to the given query is found or null of non can be deduced.</dd>
</dl>
</section>
</li>
</ul>
</section>
</li>
</ul>
</section>
<!-- ========= END OF CLASS DATA ========= -->
</main>
<footer role="contentinfo">
<hr>
<p class="legal-copy"><small>Copyright &#169; 2023 <a href="https://www.apache.org/">The Apache Software Foundation</a>. All rights reserved.</small></p>
</footer>
</div>
</div>
</body>
</html>
