<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>ProtonStreamDecoder (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.decoders, class: ProtonStreamDecoder">
<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/ProtonStreamDecoder.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.decoders</a></div>
<h1 title="Class ProtonStreamDecoder" class="title">Class ProtonStreamDecoder</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.decoders.ProtonStreamDecoder</div>
</div>
<section class="class-description" id="class-description">
<dl class="notes">
<dt>All Implemented Interfaces:</dt>
<dd><code><a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</a></code></dd>
</dl>
<hr>
<div class="type-signature"><span class="modifiers">public final class </span><span class="element-name type-name-label">ProtonStreamDecoder</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="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</a></span></div>
<div class="block">The default AMQP Decoder 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">ProtonStreamDecoder</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="ProtonStreamDecoderState.html" title="class in org.apache.qpid.protonj2.codec.decoders">ProtonStreamDecoderState</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getCachedDecoderState()" class="member-name-link">getCachedDecoderState</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="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>StreamDecoderState</code></a> instance that is meant to be shared within single threaded
 decoder interactions.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ProtonStreamDecoderState.html" title="class in org.apache.qpid.protonj2.codec.decoders">ProtonStreamDecoderState</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#newDecoderState()" class="member-name-link">newDecoderState</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Creates a new <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>StreamDecoderState</code></a> instance that can be used when interacting with the
 Decoder.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../StreamTypeDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamTypeDecoder</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="#peekNextTypeDecoder(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)" class="member-name-link">peekNextTypeDecoder</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</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">Peeks ahead in the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> instance and returns a <a href="../TypeDecoder.html" title="interface in org.apache.qpid.protonj2.codec"><code>TypeDecoder</code></a> that can
 read the next encoded AMQP type from the stream's bytes.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../../types/Binary.html" title="class in org.apache.qpid.protonj2.types">Binary</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#readBinary(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)" class="member-name-link">readBinary</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Reads an encoded <a href="../../types/Binary.html" title="class in org.apache.qpid.protonj2.types"><code>Binary</code></a> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#readBinaryAsBuffer(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)" class="member-name-link">readBinaryAsBuffer</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</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">Reads an encoded <a href="../../types/Binary.html" title="class in org.apache.qpid.protonj2.types"><code>Binary</code></a> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#readBoolean(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)" class="member-name-link">readBoolean</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Reads an encoded <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> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#readBoolean(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,boolean)" class="member-name-link">readBoolean</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state,
 boolean&nbsp;defaultValue)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Reads an encoded <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> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Byte.html" title="class or interface in java.lang" class="external-link">Byte</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#readByte(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)" class="member-name-link">readByte</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Reads an encoded <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> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>byte</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#readByte(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,byte)" class="member-name-link">readByte</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state,
 byte&nbsp;defaultValue)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Reads an encoded <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> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Character.html" title="class or interface in java.lang" class="external-link">Character</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#readCharacter(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)" class="member-name-link">readCharacter</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Reads an encoded <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> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>char</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#readCharacter(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,char)" class="member-name-link">readCharacter</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state,
 char&nbsp;defaultValue)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Reads an encoded <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> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../../types/Decimal128.html" title="class in org.apache.qpid.protonj2.types">Decimal128</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#readDecimal128(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)" class="member-name-link">readDecimal128</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Reads an encoded <a href="../../types/Decimal128.html" title="class in org.apache.qpid.protonj2.types"><code>Decimal128</code></a> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../../types/Decimal32.html" title="class in org.apache.qpid.protonj2.types">Decimal32</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#readDecimal32(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)" class="member-name-link">readDecimal32</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</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">Reads an encoded <a href="../../types/Decimal32.html" title="class in org.apache.qpid.protonj2.types"><code>Decimal32</code></a> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../../types/Decimal64.html" title="class in org.apache.qpid.protonj2.types">Decimal64</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#readDecimal64(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)" class="member-name-link">readDecimal64</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Reads an encoded <a href="../../types/Decimal64.html" title="class in org.apache.qpid.protonj2.types"><code>Decimal64</code></a> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../../types/DeliveryTag.html" title="interface in org.apache.qpid.protonj2.types">DeliveryTag</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#readDeliveryTag(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)" class="member-name-link">readDeliveryTag</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</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">This method expects to read a <a href="../../types/Binary.html" title="class in org.apache.qpid.protonj2.types"><code>Binary</code></a> encoded type from the provided stream and
 constructs a <a href="../../types/DeliveryTag.html" title="interface in org.apache.qpid.protonj2.types"><code>DeliveryTag</code></a> type that wraps the bytes encoded.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Double.html" title="class or interface in java.lang" class="external-link">Double</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#readDouble(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)" class="member-name-link">readDouble</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Reads an encoded <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> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>double</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#readDouble(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,double)" class="member-name-link">readDouble</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state,
 double&nbsp;defaultValue)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Reads an encoded <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> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Float.html" title="class or interface in java.lang" class="external-link">Float</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#readFloat(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)" class="member-name-link">readFloat</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Reads an encoded <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> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>float</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#readFloat(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,float)" class="member-name-link">readFloat</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state,
 float&nbsp;defaultValue)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Reads an encoded <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> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#readInteger(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)" class="member-name-link">readInteger</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Reads an encoded <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> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#readInteger(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,int)" class="member-name-link">readInteger</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state,
 int&nbsp;defaultValue)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Reads an encoded <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> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.</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="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;V&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#readList(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)" class="member-name-link">readList</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Reads an encoded <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> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#readLong(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)" class="member-name-link">readLong</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</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">Reads an encoded <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> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>long</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#readLong(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,long)" class="member-name-link">readLong</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state,
 long&nbsp;defaultValue)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Reads an encoded <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> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>&lt;K,<wbr>
V&gt;&nbsp;<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;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#readMap(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)" class="member-name-link">readMap</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</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">Reads an encoded <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> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>&lt;T&gt;&nbsp;T[]</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#readMultiple(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,java.lang.Class)" class="member-name-link">readMultiple</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state,
 <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;T&gt;&nbsp;clazz)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Reads one or more encoded values from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> an return it as an array of
 <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> instances which the caller must then interpret.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../StreamTypeDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamTypeDecoder</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="#readNextTypeDecoder(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)" class="member-name-link">readNextTypeDecoder</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</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">Reads from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> instance and returns a <a href="../StreamTypeDecoder.html" title="interface in org.apache.qpid.protonj2.codec"><code>StreamTypeDecoder</code></a> that can
 read the next encoded AMQP type from the stream's bytes.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#readObject(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)" class="member-name-link">readObject</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Reads an encoded value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> an return it as 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>
 which the caller must then interpret.</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;T</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#readObject(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,java.lang.Class)" class="member-name-link">readObject</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state,
 <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;T&gt;&nbsp;clazz)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Reads an encoded value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> an return it as 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>
 which the caller must then interpret.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Short.html" title="class or interface in java.lang" class="external-link">Short</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#readShort(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)" class="member-name-link">readShort</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Reads an encoded <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> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>short</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#readShort(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,short)" class="member-name-link">readShort</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state,
 short&nbsp;defaultValue)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Reads an encoded <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> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#readString(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)" class="member-name-link">readString</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Reads an encoded <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> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../../types/Symbol.html" title="class in org.apache.qpid.protonj2.types">Symbol</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#readSymbol(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)" class="member-name-link">readSymbol</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</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">Reads an encoded <a href="../../types/Symbol.html" title="class in org.apache.qpid.protonj2.types"><code>Symbol</code></a> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#readSymbol(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,java.lang.String)" class="member-name-link">readSymbol</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</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;defaultValue)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Reads an encoded <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> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#readTimestamp(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)" class="member-name-link">readTimestamp</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</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">Reads an encoded AMQP time stamp value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>long</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#readTimestamp(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,long)" class="member-name-link">readTimestamp</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state,
 long&nbsp;defaultValue)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Reads an encoded AMQP time stamp value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../../types/UnsignedByte.html" title="class in org.apache.qpid.protonj2.types">UnsignedByte</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#readUnsignedByte(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)" class="member-name-link">readUnsignedByte</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</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">Reads an encoded <a href="../../types/UnsignedByte.html" title="class in org.apache.qpid.protonj2.types"><code>UnsignedByte</code></a> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>byte</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#readUnsignedByte(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,byte)" class="member-name-link">readUnsignedByte</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state,
 byte&nbsp;defaultValue)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Reads an encoded <a href="../../types/UnsignedByte.html" title="class in org.apache.qpid.protonj2.types"><code>UnsignedByte</code></a> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../../types/UnsignedInteger.html" title="class in org.apache.qpid.protonj2.types">UnsignedInteger</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#readUnsignedInteger(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)" class="member-name-link">readUnsignedInteger</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</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">Reads an encoded <a href="../../types/UnsignedInteger.html" title="class in org.apache.qpid.protonj2.types"><code>UnsignedInteger</code></a> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#readUnsignedInteger(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,int)" class="member-name-link">readUnsignedInteger</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state,
 int&nbsp;defaultValue)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Reads an encoded <a href="../../types/UnsignedInteger.html" title="class in org.apache.qpid.protonj2.types"><code>UnsignedInteger</code></a> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>long</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#readUnsignedInteger(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,long)" class="member-name-link">readUnsignedInteger</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state,
 long&nbsp;defaultValue)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Reads an encoded <a href="../../types/UnsignedInteger.html" title="class in org.apache.qpid.protonj2.types"><code>UnsignedInteger</code></a> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../../types/UnsignedLong.html" title="class in org.apache.qpid.protonj2.types">UnsignedLong</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#readUnsignedLong(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)" class="member-name-link">readUnsignedLong</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Reads an encoded <a href="../../types/UnsignedLong.html" title="class in org.apache.qpid.protonj2.types"><code>UnsignedLong</code></a> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>long</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#readUnsignedLong(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,long)" class="member-name-link">readUnsignedLong</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state,
 long&nbsp;defaultValue)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Reads an encoded <a href="../../types/UnsignedLong.html" title="class in org.apache.qpid.protonj2.types"><code>UnsignedLong</code></a> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../../types/UnsignedShort.html" title="class in org.apache.qpid.protonj2.types">UnsignedShort</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#readUnsignedShort(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)" class="member-name-link">readUnsignedShort</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Reads an encoded <a href="../../types/UnsignedShort.html" title="class in org.apache.qpid.protonj2.types"><code>UnsignedShort</code></a> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#readUnsignedShort(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,int)" class="member-name-link">readUnsignedShort</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state,
 int&nbsp;defaultValue)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Reads an encoded <a href="../../types/UnsignedShort.html" title="class in org.apache.qpid.protonj2.types"><code>UnsignedShort</code></a> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>short</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#readUnsignedShort(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,short)" class="member-name-link">readUnsignedShort</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state,
 short&nbsp;defaultValue)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Reads an encoded <a href="../../types/UnsignedShort.html" title="class in org.apache.qpid.protonj2.types"><code>UnsignedShort</code></a> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/UUID.html" title="class or interface in java.util" class="external-link">UUID</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#readUUID(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)" class="member-name-link">readUUID</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</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">Reads an encoded <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> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.</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="ProtonStreamDecoder.html" title="class in org.apache.qpid.protonj2.codec.decoders">ProtonStreamDecoder</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#registerDescribedTypeDecoder(org.apache.qpid.protonj2.codec.StreamDescribedTypeDecoder)" class="member-name-link">registerDescribedTypeDecoder</a><wbr>(<a href="../StreamDescribedTypeDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDescribedTypeDecoder</a>&lt;V&gt;&nbsp;decoder)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Allows custom <a href="../StreamDescribedTypeDecoder.html" title="interface in org.apache.qpid.protonj2.codec"><code>StreamDescribedTypeDecoder</code></a> instances to be registered with this <a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec"><code>StreamDecoder</code></a>
 which will be used if the described type encoding is encountered during decode operations.</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>ProtonStreamDecoder</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="element-name">ProtonStreamDecoder</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="newDecoderState()">
<h3>newDecoderState</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ProtonStreamDecoderState.html" title="class in org.apache.qpid.protonj2.codec.decoders">ProtonStreamDecoderState</a></span>&nbsp;<span class="element-name">newDecoderState</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../StreamDecoder.html#newDecoderState()">StreamDecoder</a></code></span></div>
<div class="block">Creates a new <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>StreamDecoderState</code></a> instance that can be used when interacting with the
 Decoder.  For decoding that occurs on more than one thread while sharing a single
 <a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec"><code>StreamDecoder</code></a> instance a different state object per thread is required as the
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>StreamDecoderState</code></a> object can retain some state information during the decode process
 that could be corrupted if more than one thread were to share a single instance.

 For single threaded decoding work the <a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec"><code>StreamDecoder</code></a> offers a utility
 cached <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>StreamDecoderState</code></a> API that will return the same instance on each call which can
 reduce allocation overhead and make using the <a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec"><code>StreamDecoder</code></a> simpler.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../StreamDecoder.html#newDecoderState()">newDecoderState</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</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="getCachedDecoderState()">
<h3>getCachedDecoderState</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ProtonStreamDecoderState.html" title="class in org.apache.qpid.protonj2.codec.decoders">ProtonStreamDecoderState</a></span>&nbsp;<span class="element-name">getCachedDecoderState</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../StreamDecoder.html#getCachedDecoderState()">StreamDecoder</a></code></span></div>
<div class="block">Return a singleton <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>StreamDecoderState</code></a> instance that is meant to be shared within single threaded
 decoder interactions.  If more than one thread makes use of this cached <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>StreamDecoderState</code></a> the
 results of any decoding 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="../StreamDecoder.html#getCachedDecoderState()">getCachedDecoderState</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</a></code></dd>
<dt>Returns:</dt>
<dd>a cached <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>StreamDecoderState</code></a> linked to this Decoder instance that has been reset.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readObject(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">
<h3>readObject</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></span>&nbsp;<span class="element-name">readObject</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state)</span>
                  throws <span class="exceptions"><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../StreamDecoder.html#readObject(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">StreamDecoder</a></code></span></div>
<div class="block">Reads an encoded value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> an return it as 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>
 which the caller must then interpret.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../StreamDecoder.html#readObject(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">readObject</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</a></code></dd>
<dt>Parameters:</dt>
<dd><code>stream</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> where the read operation takes place.</dd>
<dd><code>state</code> - The <a href="../DecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>DecoderState</code></a> that the decoder can use when decoding.</dd>
<dt>Returns:</dt>
<dd>the value read from the provided byte source.</dd>
<dt>Throws:</dt>
<dd><code><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></code> - if the value fails to decode is not able to be decoded.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readObject(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,java.lang.Class)">
<h3>readObject</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="type-parameters">&lt;T&gt;</span>&nbsp;<span class="return-type">T</span>&nbsp;<span class="element-name">readObject</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state,
 <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;T&gt;&nbsp;clazz)</span>
                 throws <span class="exceptions"><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../StreamDecoder.html#readObject(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,java.lang.Class)">StreamDecoder</a></code></span></div>
<div class="block">Reads an encoded value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> an return it as 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>
 which the caller must then interpret.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../StreamDecoder.html#readObject(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,java.lang.Class)">readObject</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</a></code></dd>
<dt>Type Parameters:</dt>
<dd><code>T</code> - the type that will be used when casting and returning the decoded value.</dd>
<dt>Parameters:</dt>
<dd><code>stream</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> where the read operation takes place.</dd>
<dd><code>state</code> - The <a href="../DecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>DecoderState</code></a> that the decoder can use when decoding.</dd>
<dd><code>clazz</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> type that should be used to cast the returned value.</dd>
<dt>Returns:</dt>
<dd>the value read from the provided byte source.</dd>
<dt>Throws:</dt>
<dd><code><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></code> - if the value fails to decode is not able to be decoded.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readMultiple(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,java.lang.Class)">
<h3>readMultiple</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="type-parameters">&lt;T&gt;</span>&nbsp;<span class="return-type">T[]</span>&nbsp;<span class="element-name">readMultiple</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state,
 <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;T&gt;&nbsp;clazz)</span>
                     throws <span class="exceptions"><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../StreamDecoder.html#readMultiple(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,java.lang.Class)">StreamDecoder</a></code></span></div>
<div class="block">Reads one or more encoded values from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> an return it as an array of
 <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> instances which the caller must then interpret.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../StreamDecoder.html#readMultiple(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,java.lang.Class)">readMultiple</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</a></code></dd>
<dt>Type Parameters:</dt>
<dd><code>T</code> - the type that will be used when casting and returning the decoded value.</dd>
<dt>Parameters:</dt>
<dd><code>stream</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> where the read operation takes place.</dd>
<dd><code>state</code> - The <a href="../DecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>DecoderState</code></a> that the decoder can use when decoding.</dd>
<dd><code>clazz</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> type that should be used to cast the returned array.</dd>
<dt>Returns:</dt>
<dd>the value read from the provided byte source.</dd>
<dt>Throws:</dt>
<dd><code><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></code> - if the value fails to decode is not able to be decoded.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readNextTypeDecoder(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">
<h3>readNextTypeDecoder</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../StreamTypeDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamTypeDecoder</a>&lt;?&gt;</span>&nbsp;<span class="element-name">readNextTypeDecoder</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state)</span>
                                         throws <span class="exceptions"><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../StreamDecoder.html#readNextTypeDecoder(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">StreamDecoder</a></code></span></div>
<div class="block">Reads from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> instance and returns a <a href="../StreamTypeDecoder.html" title="interface in org.apache.qpid.protonj2.codec"><code>StreamTypeDecoder</code></a> that can
 read the next encoded AMQP type from the stream's bytes.  If an error occurs attempting to read
 and determine the next type decoder an <a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec"><code>DecodeException</code></a> is thrown.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../StreamDecoder.html#readNextTypeDecoder(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">readNextTypeDecoder</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</a></code></dd>
<dt>Parameters:</dt>
<dd><code>stream</code> - The stream to read from to determine the next <a href="../TypeDecoder.html" title="interface in org.apache.qpid.protonj2.codec"><code>TypeDecoder</code></a> needed.</dd>
<dd><code>state</code> - The <a href="../DecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>DecoderState</code></a> value that can be used for intermediate decoding tasks.</dd>
<dt>Returns:</dt>
<dd>a <a href="../StreamTypeDecoder.html" title="interface in org.apache.qpid.protonj2.codec"><code>StreamTypeDecoder</code></a> instance that can read the next type in the stream.</dd>
<dt>Throws:</dt>
<dd><code><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></code> - if an error occurs while reading the next type decoder.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="peekNextTypeDecoder(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">
<h3>peekNextTypeDecoder</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../StreamTypeDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamTypeDecoder</a>&lt;?&gt;</span>&nbsp;<span class="element-name">peekNextTypeDecoder</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state)</span>
                                         throws <span class="exceptions"><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../StreamDecoder.html#peekNextTypeDecoder(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">StreamDecoder</a></code></span></div>
<div class="block">Peeks ahead in the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> instance and returns a <a href="../TypeDecoder.html" title="interface in org.apache.qpid.protonj2.codec"><code>TypeDecoder</code></a> that can
 read the next encoded AMQP type from the stream's bytes.  If an error occurs attempting to read
 and determine the next type decoder an <a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec"><code>DecodeException</code></a> is thrown.  The underlying stream
 is not modified as a result of the peek operation and the returned <a href="../TypeDecoder.html" title="interface in org.apache.qpid.protonj2.codec"><code>TypeDecoder</code></a> will fail
 to properly read the type until the encoding bytes are read.  If the provided stream does not offer
 support for the mark API than this method can throw an <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/UnsupportedOperationException.html" title="class or interface in java.lang" class="external-link"><code>UnsupportedOperationException</code></a>.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../StreamDecoder.html#peekNextTypeDecoder(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">peekNextTypeDecoder</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</a></code></dd>
<dt>Parameters:</dt>
<dd><code>stream</code> - The stream to read from to determine the next <a href="../TypeDecoder.html" title="interface in org.apache.qpid.protonj2.codec"><code>TypeDecoder</code></a> needed.</dd>
<dd><code>state</code> - The <a href="../DecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>DecoderState</code></a> value that can be used for intermediate decoding tasks.</dd>
<dt>Returns:</dt>
<dd>a <a href="../TypeDecoder.html" title="interface in org.apache.qpid.protonj2.codec"><code>TypeDecoder</code></a> instance that can provide insight into the next type in the stream.</dd>
<dt>Throws:</dt>
<dd><code><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></code> - if an error occurs while peeking ahead for the next type decoder.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="registerDescribedTypeDecoder(org.apache.qpid.protonj2.codec.StreamDescribedTypeDecoder)">
<h3>registerDescribedTypeDecoder</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="ProtonStreamDecoder.html" title="class in org.apache.qpid.protonj2.codec.decoders">ProtonStreamDecoder</a></span>&nbsp;<span class="element-name">registerDescribedTypeDecoder</span><wbr><span class="parameters">(<a href="../StreamDescribedTypeDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDescribedTypeDecoder</a>&lt;V&gt;&nbsp;decoder)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../StreamDecoder.html#registerDescribedTypeDecoder(org.apache.qpid.protonj2.codec.StreamDescribedTypeDecoder)">StreamDecoder</a></code></span></div>
<div class="block">Allows custom <a href="../StreamDescribedTypeDecoder.html" title="interface in org.apache.qpid.protonj2.codec"><code>StreamDescribedTypeDecoder</code></a> instances to be registered with this <a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec"><code>StreamDecoder</code></a>
 which will be used if the described type encoding is encountered during decode operations.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../StreamDecoder.html#registerDescribedTypeDecoder(org.apache.qpid.protonj2.codec.StreamDescribedTypeDecoder)">registerDescribedTypeDecoder</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</a></code></dd>
<dt>Type Parameters:</dt>
<dd><code>V</code> - The type that the decoder reads.</dd>
<dt>Parameters:</dt>
<dd><code>decoder</code> - A <a href="../StreamDescribedTypeDecoder.html" title="interface in org.apache.qpid.protonj2.codec"><code>StreamDescribedTypeDecoder</code></a> instance to be registered with this <a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec"><code>StreamDecoder</code></a></dd>
<dt>Returns:</dt>
<dd>this <a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec"><code>StreamDecoder</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readBoolean(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">
<h3>readBoolean</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a></span>&nbsp;<span class="element-name">readBoolean</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state)</span>
                    throws <span class="exceptions"><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../StreamDecoder.html#readBoolean(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">StreamDecoder</a></code></span></div>
<div class="block">Reads an encoded <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> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.  The operation fails if the next encoded type is
 not what was expected.  If the caller wishes to recover from failed decode attempt they should
 make a note of the current read position and reset the input to make a further read attempt.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../StreamDecoder.html#readBoolean(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">readBoolean</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</a></code></dd>
<dt>Parameters:</dt>
<dd><code>stream</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> where the read operation takes place.</dd>
<dd><code>state</code> - The <a href="../DecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>DecoderState</code></a> that the decoder can use when decoding.</dd>
<dt>Returns:</dt>
<dd>the value read from the provided byte source.</dd>
<dt>Throws:</dt>
<dd><code><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></code> - if the value fails to decode is not of the expected type,</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readBoolean(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,boolean)">
<h3>readBoolean</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">readBoolean</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state,
 boolean&nbsp;defaultValue)</span>
                    throws <span class="exceptions"><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../StreamDecoder.html#readBoolean(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,boolean)">StreamDecoder</a></code></span></div>
<div class="block">Reads an encoded <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> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.  The operation fails if the next encoded type is
 not what was expected.  If the caller wishes to recover from failed decode attempt they should
 make a note of the current read position and reset the input to make a further read attempt.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../StreamDecoder.html#readBoolean(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,boolean)">readBoolean</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</a></code></dd>
<dt>Parameters:</dt>
<dd><code>stream</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> where the read operation takes place.</dd>
<dd><code>state</code> - The <a href="../DecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>DecoderState</code></a> that the decoder can use when decoding.</dd>
<dd><code>defaultValue</code> - A default value to return if the next encoded value is a Null encoding.</dd>
<dt>Returns:</dt>
<dd>the value read from the provided byte source.</dd>
<dt>Throws:</dt>
<dd><code><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></code> - if the value fails to decode is not of the expected type,</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readByte(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">
<h3>readByte</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Byte.html" title="class or interface in java.lang" class="external-link">Byte</a></span>&nbsp;<span class="element-name">readByte</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state)</span>
              throws <span class="exceptions"><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../StreamDecoder.html#readByte(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">StreamDecoder</a></code></span></div>
<div class="block">Reads an encoded <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> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.  The operation fails if the next encoded type is
 not what was expected.  If the caller wishes to recover from failed decode attempt they should
 make a note of the current read position and reset the input to make a further read attempt.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../StreamDecoder.html#readByte(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">readByte</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</a></code></dd>
<dt>Parameters:</dt>
<dd><code>stream</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> where the read operation takes place.</dd>
<dd><code>state</code> - The <a href="../DecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>DecoderState</code></a> that the decoder can use when decoding.</dd>
<dt>Returns:</dt>
<dd>the value read from the provided byte source.</dd>
<dt>Throws:</dt>
<dd><code><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></code> - if the value fails to decode is not of the expected type,</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readByte(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,byte)">
<h3>readByte</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">byte</span>&nbsp;<span class="element-name">readByte</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state,
 byte&nbsp;defaultValue)</span>
              throws <span class="exceptions"><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../StreamDecoder.html#readByte(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,byte)">StreamDecoder</a></code></span></div>
<div class="block">Reads an encoded <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> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.  The operation fails if the next encoded type is
 not what was expected.  If the caller wishes to recover from failed decode attempt they should
 make a note of the current read position and reset the input to make a further read attempt.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../StreamDecoder.html#readByte(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,byte)">readByte</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</a></code></dd>
<dt>Parameters:</dt>
<dd><code>stream</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> where the read operation takes place.</dd>
<dd><code>state</code> - The <a href="../DecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>DecoderState</code></a> that the decoder can use when decoding.</dd>
<dd><code>defaultValue</code> - A default value to return if the next encoded value is a Null encoding.</dd>
<dt>Returns:</dt>
<dd>the value read from the provided byte source.</dd>
<dt>Throws:</dt>
<dd><code><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></code> - if the value fails to decode is not of the expected type,</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readUnsignedByte(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">
<h3>readUnsignedByte</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../../types/UnsignedByte.html" title="class in org.apache.qpid.protonj2.types">UnsignedByte</a></span>&nbsp;<span class="element-name">readUnsignedByte</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state)</span>
                              throws <span class="exceptions"><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../StreamDecoder.html#readUnsignedByte(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">StreamDecoder</a></code></span></div>
<div class="block">Reads an encoded <a href="../../types/UnsignedByte.html" title="class in org.apache.qpid.protonj2.types"><code>UnsignedByte</code></a> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.  The operation fails if the next encoded type is
 not what was expected.  If the caller wishes to recover from failed decode attempt they should
 make a note of the current read position and reset the input to make a further read attempt.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../StreamDecoder.html#readUnsignedByte(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">readUnsignedByte</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</a></code></dd>
<dt>Parameters:</dt>
<dd><code>stream</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> where the read operation takes place.</dd>
<dd><code>state</code> - The <a href="../DecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>DecoderState</code></a> that the decoder can use when decoding.</dd>
<dt>Returns:</dt>
<dd>the value read from the provided byte source.</dd>
<dt>Throws:</dt>
<dd><code><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></code> - if the value fails to decode is not of the expected type,</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readUnsignedByte(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,byte)">
<h3>readUnsignedByte</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">byte</span>&nbsp;<span class="element-name">readUnsignedByte</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state,
 byte&nbsp;defaultValue)</span>
                      throws <span class="exceptions"><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../StreamDecoder.html#readUnsignedByte(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,byte)">StreamDecoder</a></code></span></div>
<div class="block">Reads an encoded <a href="../../types/UnsignedByte.html" title="class in org.apache.qpid.protonj2.types"><code>UnsignedByte</code></a> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.  The operation fails if the next encoded type is
 not what was expected.  If the caller wishes to recover from failed decode attempt they should
 make a note of the current read position and reset the input to make a further read attempt.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../StreamDecoder.html#readUnsignedByte(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,byte)">readUnsignedByte</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</a></code></dd>
<dt>Parameters:</dt>
<dd><code>stream</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> where the read operation takes place.</dd>
<dd><code>state</code> - The <a href="../DecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>DecoderState</code></a> that the decoder can use when decoding.</dd>
<dd><code>defaultValue</code> - A default value to return if the next encoded value is a Null encoding.</dd>
<dt>Returns:</dt>
<dd>the value read from the provided byte source.</dd>
<dt>Throws:</dt>
<dd><code><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></code> - if the value fails to decode is not of the expected type,</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readCharacter(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">
<h3>readCharacter</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Character.html" title="class or interface in java.lang" class="external-link">Character</a></span>&nbsp;<span class="element-name">readCharacter</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state)</span>
                        throws <span class="exceptions"><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../StreamDecoder.html#readCharacter(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">StreamDecoder</a></code></span></div>
<div class="block">Reads an encoded <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> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.  The operation fails if the next encoded type is
 not what was expected.  If the caller wishes to recover from failed decode attempt they should
 make a note of the current read position and reset the input to make a further read attempt.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../StreamDecoder.html#readCharacter(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">readCharacter</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</a></code></dd>
<dt>Parameters:</dt>
<dd><code>stream</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> where the read operation takes place.</dd>
<dd><code>state</code> - The <a href="../DecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>DecoderState</code></a> that the decoder can use when decoding.</dd>
<dt>Returns:</dt>
<dd>the value read from the provided byte source.</dd>
<dt>Throws:</dt>
<dd><code><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></code> - if the value fails to decode is not of the expected type,</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readCharacter(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,char)">
<h3>readCharacter</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">char</span>&nbsp;<span class="element-name">readCharacter</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state,
 char&nbsp;defaultValue)</span>
                   throws <span class="exceptions"><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../StreamDecoder.html#readCharacter(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,char)">StreamDecoder</a></code></span></div>
<div class="block">Reads an encoded <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> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.  The operation fails if the next encoded type is
 not what was expected.  If the caller wishes to recover from failed decode attempt they should
 make a note of the current read position and reset the input to make a further read attempt.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../StreamDecoder.html#readCharacter(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,char)">readCharacter</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</a></code></dd>
<dt>Parameters:</dt>
<dd><code>stream</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> where the read operation takes place.</dd>
<dd><code>state</code> - The <a href="../DecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>DecoderState</code></a> that the decoder can use when decoding.</dd>
<dd><code>defaultValue</code> - A default value to return if the next encoded value is a Null encoding.</dd>
<dt>Returns:</dt>
<dd>the value read from the provided byte source.</dd>
<dt>Throws:</dt>
<dd><code><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></code> - if the value fails to decode is not of the expected type,</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readDecimal32(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">
<h3>readDecimal32</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../../types/Decimal32.html" title="class in org.apache.qpid.protonj2.types">Decimal32</a></span>&nbsp;<span class="element-name">readDecimal32</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state)</span>
                        throws <span class="exceptions"><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../StreamDecoder.html#readDecimal32(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">StreamDecoder</a></code></span></div>
<div class="block">Reads an encoded <a href="../../types/Decimal32.html" title="class in org.apache.qpid.protonj2.types"><code>Decimal32</code></a> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.  The operation fails if the next encoded type is
 not what was expected.  If the caller wishes to recover from failed decode attempt they should
 make a note of the current read position and reset the input to make a further read attempt.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../StreamDecoder.html#readDecimal32(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">readDecimal32</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</a></code></dd>
<dt>Parameters:</dt>
<dd><code>stream</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> where the read operation takes place.</dd>
<dd><code>state</code> - The <a href="../DecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>DecoderState</code></a> that the decoder can use when decoding.</dd>
<dt>Returns:</dt>
<dd>the value read from the provided byte source.</dd>
<dt>Throws:</dt>
<dd><code><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></code> - if the value fails to decode is not of the expected type,</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readDecimal64(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">
<h3>readDecimal64</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../../types/Decimal64.html" title="class in org.apache.qpid.protonj2.types">Decimal64</a></span>&nbsp;<span class="element-name">readDecimal64</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state)</span>
                        throws <span class="exceptions"><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../StreamDecoder.html#readDecimal64(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">StreamDecoder</a></code></span></div>
<div class="block">Reads an encoded <a href="../../types/Decimal64.html" title="class in org.apache.qpid.protonj2.types"><code>Decimal64</code></a> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.  The operation fails if the next encoded type is
 not what was expected.  If the caller wishes to recover from failed decode attempt they should
 make a note of the current read position and reset the input to make a further read attempt.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../StreamDecoder.html#readDecimal64(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">readDecimal64</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</a></code></dd>
<dt>Parameters:</dt>
<dd><code>stream</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> where the read operation takes place.</dd>
<dd><code>state</code> - The <a href="../DecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>DecoderState</code></a> that the decoder can use when decoding.</dd>
<dt>Returns:</dt>
<dd>the value read from the provided byte source.</dd>
<dt>Throws:</dt>
<dd><code><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></code> - if the value fails to decode is not of the expected type,</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readDecimal128(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">
<h3>readDecimal128</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../../types/Decimal128.html" title="class in org.apache.qpid.protonj2.types">Decimal128</a></span>&nbsp;<span class="element-name">readDecimal128</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state)</span>
                          throws <span class="exceptions"><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../StreamDecoder.html#readDecimal128(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">StreamDecoder</a></code></span></div>
<div class="block">Reads an encoded <a href="../../types/Decimal128.html" title="class in org.apache.qpid.protonj2.types"><code>Decimal128</code></a> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.  The operation fails if the next encoded type is
 not what was expected.  If the caller wishes to recover from failed decode attempt they should
 make a note of the current read position and reset the input to make a further read attempt.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../StreamDecoder.html#readDecimal128(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">readDecimal128</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</a></code></dd>
<dt>Parameters:</dt>
<dd><code>stream</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> where the read operation takes place.</dd>
<dd><code>state</code> - The <a href="../DecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>DecoderState</code></a> that the decoder can use when decoding.</dd>
<dt>Returns:</dt>
<dd>the value read from the provided byte source.</dd>
<dt>Throws:</dt>
<dd><code><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></code> - if the value fails to decode is not of the expected type,</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readShort(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">
<h3>readShort</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Short.html" title="class or interface in java.lang" class="external-link">Short</a></span>&nbsp;<span class="element-name">readShort</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state)</span>
                throws <span class="exceptions"><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../StreamDecoder.html#readShort(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">StreamDecoder</a></code></span></div>
<div class="block">Reads an encoded <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> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.  The operation fails if the next encoded type is
 not what was expected.  If the caller wishes to recover from failed decode attempt they should
 make a note of the current read position and reset the input to make a further read attempt.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../StreamDecoder.html#readShort(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">readShort</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</a></code></dd>
<dt>Parameters:</dt>
<dd><code>stream</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> where the read operation takes place.</dd>
<dd><code>state</code> - The <a href="../DecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>DecoderState</code></a> that the decoder can use when decoding.</dd>
<dt>Returns:</dt>
<dd>the value read from the provided byte source.</dd>
<dt>Throws:</dt>
<dd><code><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></code> - if the value fails to decode is not of the expected type,</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readShort(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,short)">
<h3>readShort</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">short</span>&nbsp;<span class="element-name">readShort</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state,
 short&nbsp;defaultValue)</span>
                throws <span class="exceptions"><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../StreamDecoder.html#readShort(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,short)">StreamDecoder</a></code></span></div>
<div class="block">Reads an encoded <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> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.  The operation fails if the next encoded type is
 not what was expected.  If the caller wishes to recover from failed decode attempt they should
 make a note of the current read position and reset the input to make a further read attempt.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../StreamDecoder.html#readShort(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,short)">readShort</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</a></code></dd>
<dt>Parameters:</dt>
<dd><code>stream</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> where the read operation takes place.</dd>
<dd><code>state</code> - The <a href="../DecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>DecoderState</code></a> that the decoder can use when decoding.</dd>
<dd><code>defaultValue</code> - A default value to return if the next encoded value is a Null encoding.</dd>
<dt>Returns:</dt>
<dd>the value read from the provided byte source.</dd>
<dt>Throws:</dt>
<dd><code><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></code> - if the value fails to decode is not of the expected type,</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readUnsignedShort(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">
<h3>readUnsignedShort</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../../types/UnsignedShort.html" title="class in org.apache.qpid.protonj2.types">UnsignedShort</a></span>&nbsp;<span class="element-name">readUnsignedShort</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state)</span>
                                throws <span class="exceptions"><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../StreamDecoder.html#readUnsignedShort(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">StreamDecoder</a></code></span></div>
<div class="block">Reads an encoded <a href="../../types/UnsignedShort.html" title="class in org.apache.qpid.protonj2.types"><code>UnsignedShort</code></a> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.  The operation fails if the next encoded type is
 not what was expected.  If the caller wishes to recover from failed decode attempt they should
 make a note of the current read position and reset the input to make a further read attempt.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../StreamDecoder.html#readUnsignedShort(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">readUnsignedShort</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</a></code></dd>
<dt>Parameters:</dt>
<dd><code>stream</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> where the read operation takes place.</dd>
<dd><code>state</code> - The <a href="../DecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>DecoderState</code></a> that the decoder can use when decoding.</dd>
<dt>Returns:</dt>
<dd>the value read from the provided byte source.</dd>
<dt>Throws:</dt>
<dd><code><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></code> - if the value fails to decode is not of the expected type,</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readUnsignedShort(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,short)">
<h3>readUnsignedShort</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">short</span>&nbsp;<span class="element-name">readUnsignedShort</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state,
 short&nbsp;defaultValue)</span>
                        throws <span class="exceptions"><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../StreamDecoder.html#readUnsignedShort(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,short)">StreamDecoder</a></code></span></div>
<div class="block">Reads an encoded <a href="../../types/UnsignedShort.html" title="class in org.apache.qpid.protonj2.types"><code>UnsignedShort</code></a> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.  The operation fails if the next encoded type is
 not what was expected.  If the caller wishes to recover from failed decode attempt they should
 make a note of the current read position and reset the input to make a further read attempt.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../StreamDecoder.html#readUnsignedShort(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,short)">readUnsignedShort</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</a></code></dd>
<dt>Parameters:</dt>
<dd><code>stream</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> where the read operation takes place.</dd>
<dd><code>state</code> - The <a href="../DecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>DecoderState</code></a> that the decoder can use when decoding.</dd>
<dd><code>defaultValue</code> - A default value to return if the next encoded value is a Null encoding.</dd>
<dt>Returns:</dt>
<dd>the value read from the provided byte source.</dd>
<dt>Throws:</dt>
<dd><code><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></code> - if the value fails to decode is not of the expected type,</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readUnsignedShort(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,int)">
<h3>readUnsignedShort</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">readUnsignedShort</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state,
 int&nbsp;defaultValue)</span>
                      throws <span class="exceptions"><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../StreamDecoder.html#readUnsignedShort(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,int)">StreamDecoder</a></code></span></div>
<div class="block">Reads an encoded <a href="../../types/UnsignedShort.html" title="class in org.apache.qpid.protonj2.types"><code>UnsignedShort</code></a> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.  The operation fails if the next encoded type is
 not what was expected.  If the caller wishes to recover from failed decode attempt they should
 make a note of the current read position and reset the input to make a further read attempt.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../StreamDecoder.html#readUnsignedShort(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,int)">readUnsignedShort</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</a></code></dd>
<dt>Parameters:</dt>
<dd><code>stream</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> where the read operation takes place.</dd>
<dd><code>state</code> - The <a href="../DecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>DecoderState</code></a> that the decoder can use when decoding.</dd>
<dd><code>defaultValue</code> - A default value to return if the next encoded value is a Null encoding.</dd>
<dt>Returns:</dt>
<dd>the value read from the provided byte source.</dd>
<dt>Throws:</dt>
<dd><code><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></code> - if the value fails to decode is not of the expected type,</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readInteger(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">
<h3>readInteger</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a></span>&nbsp;<span class="element-name">readInteger</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state)</span>
                    throws <span class="exceptions"><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../StreamDecoder.html#readInteger(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">StreamDecoder</a></code></span></div>
<div class="block">Reads an encoded <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> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.  The operation fails if the next encoded type is
 not what was expected.  If the caller wishes to recover from failed decode attempt they should
 make a note of the current read position and reset the input to make a further read attempt.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../StreamDecoder.html#readInteger(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">readInteger</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</a></code></dd>
<dt>Parameters:</dt>
<dd><code>stream</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> where the read operation takes place.</dd>
<dd><code>state</code> - The <a href="../DecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>DecoderState</code></a> that the decoder can use when decoding.</dd>
<dt>Returns:</dt>
<dd>the value read from the provided byte source.</dd>
<dt>Throws:</dt>
<dd><code><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></code> - if the value fails to decode is not of the expected type,</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readInteger(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,int)">
<h3>readInteger</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">readInteger</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state,
 int&nbsp;defaultValue)</span>
                throws <span class="exceptions"><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../StreamDecoder.html#readInteger(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,int)">StreamDecoder</a></code></span></div>
<div class="block">Reads an encoded <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> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.  The operation fails if the next encoded type is
 not what was expected.  If the caller wishes to recover from failed decode attempt they should
 make a note of the current read position and reset the input to make a further read attempt.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../StreamDecoder.html#readInteger(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,int)">readInteger</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</a></code></dd>
<dt>Parameters:</dt>
<dd><code>stream</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> where the read operation takes place.</dd>
<dd><code>state</code> - The <a href="../DecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>DecoderState</code></a> that the decoder can use when decoding.</dd>
<dd><code>defaultValue</code> - A default value to return if the next encoded value is a Null encoding.</dd>
<dt>Returns:</dt>
<dd>the value read from the provided byte source.</dd>
<dt>Throws:</dt>
<dd><code><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></code> - if the value fails to decode is not of the expected type,</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readUnsignedInteger(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">
<h3>readUnsignedInteger</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../../types/UnsignedInteger.html" title="class in org.apache.qpid.protonj2.types">UnsignedInteger</a></span>&nbsp;<span class="element-name">readUnsignedInteger</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state)</span>
                                    throws <span class="exceptions"><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../StreamDecoder.html#readUnsignedInteger(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">StreamDecoder</a></code></span></div>
<div class="block">Reads an encoded <a href="../../types/UnsignedInteger.html" title="class in org.apache.qpid.protonj2.types"><code>UnsignedInteger</code></a> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.  The operation fails if the next encoded type is
 not what was expected.  If the caller wishes to recover from failed decode attempt they should
 make a note of the current read position and reset the input to make a further read attempt.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../StreamDecoder.html#readUnsignedInteger(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">readUnsignedInteger</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</a></code></dd>
<dt>Parameters:</dt>
<dd><code>stream</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> where the read operation takes place.</dd>
<dd><code>state</code> - The <a href="../DecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>DecoderState</code></a> that the decoder can use when decoding.</dd>
<dt>Returns:</dt>
<dd>the value read from the provided byte source.</dd>
<dt>Throws:</dt>
<dd><code><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></code> - if the value fails to decode is not of the expected type,</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readUnsignedInteger(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,int)">
<h3>readUnsignedInteger</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">readUnsignedInteger</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state,
 int&nbsp;defaultValue)</span>
                        throws <span class="exceptions"><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../StreamDecoder.html#readUnsignedInteger(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,int)">StreamDecoder</a></code></span></div>
<div class="block">Reads an encoded <a href="../../types/UnsignedInteger.html" title="class in org.apache.qpid.protonj2.types"><code>UnsignedInteger</code></a> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.  The operation fails if the next encoded type is
 not what was expected.  If the caller wishes to recover from failed decode attempt they should
 make a note of the current read position and reset the input to make a further read attempt.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../StreamDecoder.html#readUnsignedInteger(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,int)">readUnsignedInteger</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</a></code></dd>
<dt>Parameters:</dt>
<dd><code>stream</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> where the read operation takes place.</dd>
<dd><code>state</code> - The <a href="../DecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>DecoderState</code></a> that the decoder can use when decoding.</dd>
<dd><code>defaultValue</code> - A default value to return if the next encoded value is a Null encoding.</dd>
<dt>Returns:</dt>
<dd>the value read from the provided byte source.</dd>
<dt>Throws:</dt>
<dd><code><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></code> - if the value fails to decode is not of the expected type,</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readUnsignedInteger(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,long)">
<h3>readUnsignedInteger</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">readUnsignedInteger</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state,
 long&nbsp;defaultValue)</span>
                         throws <span class="exceptions"><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../StreamDecoder.html#readUnsignedInteger(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,long)">StreamDecoder</a></code></span></div>
<div class="block">Reads an encoded <a href="../../types/UnsignedInteger.html" title="class in org.apache.qpid.protonj2.types"><code>UnsignedInteger</code></a> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.  The operation fails if the next encoded type is
 not what was expected.  If the caller wishes to recover from failed decode attempt they should
 make a note of the current read position and reset the input to make a further read attempt.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../StreamDecoder.html#readUnsignedInteger(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,long)">readUnsignedInteger</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</a></code></dd>
<dt>Parameters:</dt>
<dd><code>stream</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> where the read operation takes place.</dd>
<dd><code>state</code> - The <a href="../DecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>DecoderState</code></a> that the decoder can use when decoding.</dd>
<dd><code>defaultValue</code> - A default value to return if the next encoded value is a Null encoding.</dd>
<dt>Returns:</dt>
<dd>the value read from the provided byte source.</dd>
<dt>Throws:</dt>
<dd><code><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></code> - if the value fails to decode is not of the expected type,</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readLong(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">
<h3>readLong</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a></span>&nbsp;<span class="element-name">readLong</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state)</span>
              throws <span class="exceptions"><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../StreamDecoder.html#readLong(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">StreamDecoder</a></code></span></div>
<div class="block">Reads an encoded <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> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.  The operation fails if the next encoded type is
 not what was expected.  If the caller wishes to recover from failed decode attempt they should
 make a note of the current read position and reset the input to make a further read attempt.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../StreamDecoder.html#readLong(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">readLong</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</a></code></dd>
<dt>Parameters:</dt>
<dd><code>stream</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> where the read operation takes place.</dd>
<dd><code>state</code> - The <a href="../DecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>DecoderState</code></a> that the decoder can use when decoding.</dd>
<dt>Returns:</dt>
<dd>the value read from the provided byte source.</dd>
<dt>Throws:</dt>
<dd><code><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></code> - if the value fails to decode is not of the expected type,</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readLong(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,long)">
<h3>readLong</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">readLong</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state,
 long&nbsp;defaultValue)</span>
              throws <span class="exceptions"><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../StreamDecoder.html#readLong(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,long)">StreamDecoder</a></code></span></div>
<div class="block">Reads an encoded <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> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.  The operation fails if the next encoded type is
 not what was expected.  If the caller wishes to recover from failed decode attempt they should
 make a note of the current read position and reset the input to make a further read attempt.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../StreamDecoder.html#readLong(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,long)">readLong</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</a></code></dd>
<dt>Parameters:</dt>
<dd><code>stream</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> where the read operation takes place.</dd>
<dd><code>state</code> - The <a href="../DecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>DecoderState</code></a> that the decoder can use when decoding.</dd>
<dd><code>defaultValue</code> - A default value to return if the next encoded value is a Null encoding.</dd>
<dt>Returns:</dt>
<dd>the value read from the provided byte source.</dd>
<dt>Throws:</dt>
<dd><code><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></code> - if the value fails to decode is not of the expected type,</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readUnsignedLong(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">
<h3>readUnsignedLong</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../../types/UnsignedLong.html" title="class in org.apache.qpid.protonj2.types">UnsignedLong</a></span>&nbsp;<span class="element-name">readUnsignedLong</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state)</span>
                              throws <span class="exceptions"><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../StreamDecoder.html#readUnsignedLong(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">StreamDecoder</a></code></span></div>
<div class="block">Reads an encoded <a href="../../types/UnsignedLong.html" title="class in org.apache.qpid.protonj2.types"><code>UnsignedLong</code></a> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.  The operation fails if the next encoded type is
 not what was expected.  If the caller wishes to recover from failed decode attempt they should
 make a note of the current read position and reset the input to make a further read attempt.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../StreamDecoder.html#readUnsignedLong(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">readUnsignedLong</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</a></code></dd>
<dt>Parameters:</dt>
<dd><code>stream</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> where the read operation takes place.</dd>
<dd><code>state</code> - The <a href="../DecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>DecoderState</code></a> that the decoder can use when decoding.</dd>
<dt>Returns:</dt>
<dd>the value read from the provided byte source.</dd>
<dt>Throws:</dt>
<dd><code><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></code> - if the value fails to decode is not of the expected type,</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readUnsignedLong(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,long)">
<h3>readUnsignedLong</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">readUnsignedLong</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state,
 long&nbsp;defaultValue)</span>
                      throws <span class="exceptions"><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../StreamDecoder.html#readUnsignedLong(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,long)">StreamDecoder</a></code></span></div>
<div class="block">Reads an encoded <a href="../../types/UnsignedLong.html" title="class in org.apache.qpid.protonj2.types"><code>UnsignedLong</code></a> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.  The operation fails if the next encoded type is
 not what was expected.  If the caller wishes to recover from failed decode attempt they should
 make a note of the current read position and reset the input to make a further read attempt.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../StreamDecoder.html#readUnsignedLong(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,long)">readUnsignedLong</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</a></code></dd>
<dt>Parameters:</dt>
<dd><code>stream</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> where the read operation takes place.</dd>
<dd><code>state</code> - The <a href="../DecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>DecoderState</code></a> that the decoder can use when decoding.</dd>
<dd><code>defaultValue</code> - A default value to return if the next encoded value is a Null encoding.</dd>
<dt>Returns:</dt>
<dd>the value read from the provided byte source.</dd>
<dt>Throws:</dt>
<dd><code><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></code> - if the value fails to decode is not of the expected type,</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readFloat(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">
<h3>readFloat</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Float.html" title="class or interface in java.lang" class="external-link">Float</a></span>&nbsp;<span class="element-name">readFloat</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state)</span>
                throws <span class="exceptions"><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../StreamDecoder.html#readFloat(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">StreamDecoder</a></code></span></div>
<div class="block">Reads an encoded <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> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.  The operation fails if the next encoded type is
 not what was expected.  If the caller wishes to recover from failed decode attempt they should
 make a note of the current read position and reset the input to make a further read attempt.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../StreamDecoder.html#readFloat(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">readFloat</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</a></code></dd>
<dt>Parameters:</dt>
<dd><code>stream</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> where the read operation takes place.</dd>
<dd><code>state</code> - The <a href="../DecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>DecoderState</code></a> that the decoder can use when decoding.</dd>
<dt>Returns:</dt>
<dd>the value read from the provided byte source.</dd>
<dt>Throws:</dt>
<dd><code><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></code> - if the value fails to decode is not of the expected type,</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readFloat(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,float)">
<h3>readFloat</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">float</span>&nbsp;<span class="element-name">readFloat</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state,
 float&nbsp;defaultValue)</span>
                throws <span class="exceptions"><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../StreamDecoder.html#readFloat(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,float)">StreamDecoder</a></code></span></div>
<div class="block">Reads an encoded <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> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.  The operation fails if the next encoded type is
 not what was expected.  If the caller wishes to recover from failed decode attempt they should
 make a note of the current read position and reset the input to make a further read attempt.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../StreamDecoder.html#readFloat(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,float)">readFloat</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</a></code></dd>
<dt>Parameters:</dt>
<dd><code>stream</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> where the read operation takes place.</dd>
<dd><code>state</code> - The <a href="../DecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>DecoderState</code></a> that the decoder can use when decoding.</dd>
<dd><code>defaultValue</code> - A default value to return if the next encoded value is a Null encoding.</dd>
<dt>Returns:</dt>
<dd>the value read from the provided byte source.</dd>
<dt>Throws:</dt>
<dd><code><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></code> - if the value fails to decode is not of the expected type,</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readDouble(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">
<h3>readDouble</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Double.html" title="class or interface in java.lang" class="external-link">Double</a></span>&nbsp;<span class="element-name">readDouble</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state)</span>
                  throws <span class="exceptions"><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../StreamDecoder.html#readDouble(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">StreamDecoder</a></code></span></div>
<div class="block">Reads an encoded <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> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.  The operation fails if the next encoded type is
 not what was expected.  If the caller wishes to recover from failed decode attempt they should
 make a note of the current read position and reset the input to make a further read attempt.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../StreamDecoder.html#readDouble(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">readDouble</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</a></code></dd>
<dt>Parameters:</dt>
<dd><code>stream</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> where the read operation takes place.</dd>
<dd><code>state</code> - The <a href="../DecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>DecoderState</code></a> that the decoder can use when decoding.</dd>
<dt>Returns:</dt>
<dd>the value read from the provided byte source.</dd>
<dt>Throws:</dt>
<dd><code><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></code> - if the value fails to decode is not of the expected type,</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readDouble(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,double)">
<h3>readDouble</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">readDouble</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state,
 double&nbsp;defaultValue)</span>
                  throws <span class="exceptions"><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../StreamDecoder.html#readDouble(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,double)">StreamDecoder</a></code></span></div>
<div class="block">Reads an encoded <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> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.  The operation fails if the next encoded type is
 not what was expected.  If the caller wishes to recover from failed decode attempt they should
 make a note of the current read position and reset the input to make a further read attempt.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../StreamDecoder.html#readDouble(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,double)">readDouble</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</a></code></dd>
<dt>Parameters:</dt>
<dd><code>stream</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> where the read operation takes place.</dd>
<dd><code>state</code> - The <a href="../DecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>DecoderState</code></a> that the decoder can use when decoding.</dd>
<dd><code>defaultValue</code> - A default value to return if the next encoded value is a Null encoding.</dd>
<dt>Returns:</dt>
<dd>the value read from the provided byte source.</dd>
<dt>Throws:</dt>
<dd><code><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></code> - if the value fails to decode is not of the expected type,</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readBinary(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">
<h3>readBinary</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../../types/Binary.html" title="class in org.apache.qpid.protonj2.types">Binary</a></span>&nbsp;<span class="element-name">readBinary</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state)</span>
                  throws <span class="exceptions"><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../StreamDecoder.html#readBinary(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">StreamDecoder</a></code></span></div>
<div class="block">Reads an encoded <a href="../../types/Binary.html" title="class in org.apache.qpid.protonj2.types"><code>Binary</code></a> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.  The operation fails if the next encoded type is
 not what was expected.  If the caller wishes to recover from failed decode attempt they should
 make a note of the current read position and reset the input to make a further read attempt.
 <p>
 The resulting <a href="../../types/Binary.html" title="class in org.apache.qpid.protonj2.types"><code>Binary</code></a> instance will contain a read-only view of the decoded bytes and
 any calls to access the underlying buffer will return a read-only <a href="../../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer"><code>ProtonBuffer</code></a>.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../StreamDecoder.html#readBinary(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">readBinary</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</a></code></dd>
<dt>Parameters:</dt>
<dd><code>stream</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> where the read operation takes place.</dd>
<dd><code>state</code> - The <a href="../DecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>DecoderState</code></a> that the decoder can use when decoding.</dd>
<dt>Returns:</dt>
<dd>the value read from the provided byte source.</dd>
<dt>Throws:</dt>
<dd><code><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></code> - if the value fails to decode is not of the expected type,</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readBinaryAsBuffer(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">
<h3>readBinaryAsBuffer</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></span>&nbsp;<span class="element-name">readBinaryAsBuffer</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state)</span>
                                throws <span class="exceptions"><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../StreamDecoder.html#readBinaryAsBuffer(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">StreamDecoder</a></code></span></div>
<div class="block">Reads an encoded <a href="../../types/Binary.html" title="class in org.apache.qpid.protonj2.types"><code>Binary</code></a> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.  The operation fails if the next encoded type is
 not what was expected.  If the caller wishes to recover from failed decode attempt they should
 make a note of the current read position and reset the input to make a further read attempt.
 <p>
 The resulting <a href="../../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer"><code>ProtonBuffer</code></a> instance will be a read-only view of the read in bytes.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../StreamDecoder.html#readBinaryAsBuffer(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">readBinaryAsBuffer</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</a></code></dd>
<dt>Parameters:</dt>
<dd><code>stream</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> where the read operation takes place.</dd>
<dd><code>state</code> - The <a href="../DecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>DecoderState</code></a> that the decoder can use when decoding.</dd>
<dt>Returns:</dt>
<dd>the value read from the provided byte source and returned in a <a href="../../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer"><code>ProtonBuffer</code></a>.</dd>
<dt>Throws:</dt>
<dd><code><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></code> - if the value fails to decode is not of the expected type,</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readDeliveryTag(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">
<h3>readDeliveryTag</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../../types/DeliveryTag.html" title="interface in org.apache.qpid.protonj2.types">DeliveryTag</a></span>&nbsp;<span class="element-name">readDeliveryTag</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state)</span>
                            throws <span class="exceptions"><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../StreamDecoder.html#readDeliveryTag(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">StreamDecoder</a></code></span></div>
<div class="block">This method expects to read a <a href="../../types/Binary.html" title="class in org.apache.qpid.protonj2.types"><code>Binary</code></a> encoded type from the provided stream and
 constructs a <a href="../../types/DeliveryTag.html" title="interface in org.apache.qpid.protonj2.types"><code>DeliveryTag</code></a> type that wraps the bytes encoded.  If the encoding is
 a NULL AMQP type then this method returns <code>null</code>.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../StreamDecoder.html#readDeliveryTag(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">readDeliveryTag</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</a></code></dd>
<dt>Parameters:</dt>
<dd><code>stream</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> to read a Binary encoded value from</dd>
<dd><code>state</code> - The current encoding state.</dd>
<dt>Returns:</dt>
<dd>a new DeliveryTag instance or null if an AMQP NULL encoding is found.</dd>
<dt>Throws:</dt>
<dd><code><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></code> - if an error occurs while decoding the <a href="../../types/DeliveryTag.html" title="interface in org.apache.qpid.protonj2.types"><code>DeliveryTag</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readString(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">
<h3>readString</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">readString</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state)</span>
                  throws <span class="exceptions"><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../StreamDecoder.html#readString(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">StreamDecoder</a></code></span></div>
<div class="block">Reads an encoded <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> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.  The operation fails if the next encoded type is
 not what was expected.  If the caller wishes to recover from failed decode attempt they should
 make a note of the current read position and reset the input to make a further read attempt.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../StreamDecoder.html#readString(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">readString</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</a></code></dd>
<dt>Parameters:</dt>
<dd><code>stream</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> where the read operation takes place.</dd>
<dd><code>state</code> - The <a href="../DecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>DecoderState</code></a> that the decoder can use when decoding.</dd>
<dt>Returns:</dt>
<dd>the value read from the provided byte source.</dd>
<dt>Throws:</dt>
<dd><code><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></code> - if the value fails to decode is not of the expected type,</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readSymbol(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">
<h3>readSymbol</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../../types/Symbol.html" title="class in org.apache.qpid.protonj2.types">Symbol</a></span>&nbsp;<span class="element-name">readSymbol</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state)</span>
                  throws <span class="exceptions"><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../StreamDecoder.html#readSymbol(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">StreamDecoder</a></code></span></div>
<div class="block">Reads an encoded <a href="../../types/Symbol.html" title="class in org.apache.qpid.protonj2.types"><code>Symbol</code></a> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.  The operation fails if the next encoded type is
 not what was expected.  If the caller wishes to recover from failed decode attempt they should
 make a note of the current read position and reset the input to make a further read attempt.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../StreamDecoder.html#readSymbol(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">readSymbol</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</a></code></dd>
<dt>Parameters:</dt>
<dd><code>stream</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> where the read operation takes place.</dd>
<dd><code>state</code> - The <a href="../DecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>DecoderState</code></a> that the decoder can use when decoding.</dd>
<dt>Returns:</dt>
<dd>the value read from the provided byte source.</dd>
<dt>Throws:</dt>
<dd><code><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></code> - if the value fails to decode is not of the expected type,</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readSymbol(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,java.lang.String)">
<h3>readSymbol</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">readSymbol</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</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;defaultValue)</span>
                  throws <span class="exceptions"><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../StreamDecoder.html#readSymbol(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,java.lang.String)">StreamDecoder</a></code></span></div>
<div class="block">Reads an encoded <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> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.  The operation fails if the next encoded type is
 not what was expected.  If the caller wishes to recover from failed decode attempt they should
 make a note of the current read position and reset the input to make a further read attempt.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../StreamDecoder.html#readSymbol(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,java.lang.String)">readSymbol</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</a></code></dd>
<dt>Parameters:</dt>
<dd><code>stream</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> where the read operation takes place.</dd>
<dd><code>state</code> - The <a href="../DecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>DecoderState</code></a> that the decoder can use when decoding.</dd>
<dd><code>defaultValue</code> - A default value to return if the next encoded value is a Null encoding.</dd>
<dt>Returns:</dt>
<dd>the value read from the provided byte source.</dd>
<dt>Throws:</dt>
<dd><code><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></code> - if the value fails to decode is not of the expected type,</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readTimestamp(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">
<h3>readTimestamp</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a></span>&nbsp;<span class="element-name">readTimestamp</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state)</span>
                   throws <span class="exceptions"><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../StreamDecoder.html#readTimestamp(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">StreamDecoder</a></code></span></div>
<div class="block">Reads an encoded AMQP time stamp value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.  The operation fails if the next encoded type is
 not what was expected.  If the caller wishes to recover from failed decode attempt they should
 make a note of the current read position and reset the input to make a further read attempt.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../StreamDecoder.html#readTimestamp(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">readTimestamp</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</a></code></dd>
<dt>Parameters:</dt>
<dd><code>stream</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> where the read operation takes place.</dd>
<dd><code>state</code> - The <a href="../DecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>DecoderState</code></a> that the decoder can use when decoding.</dd>
<dt>Returns:</dt>
<dd>the value read from the provided byte source and return 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> with the time value.</dd>
<dt>Throws:</dt>
<dd><code><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></code> - if the value fails to decode is not of the expected type,</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readTimestamp(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,long)">
<h3>readTimestamp</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">readTimestamp</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state,
 long&nbsp;defaultValue)</span>
                   throws <span class="exceptions"><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../StreamDecoder.html#readTimestamp(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,long)">StreamDecoder</a></code></span></div>
<div class="block">Reads an encoded AMQP time stamp value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.  The operation fails if the next encoded type is
 not what was expected.  If the caller wishes to recover from failed decode attempt they should
 make a note of the current read position and reset the input to make a further read attempt.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../StreamDecoder.html#readTimestamp(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState,long)">readTimestamp</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</a></code></dd>
<dt>Parameters:</dt>
<dd><code>stream</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> where the read operation takes place.</dd>
<dd><code>state</code> - The <a href="../DecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>DecoderState</code></a> that the decoder can use when decoding.</dd>
<dd><code>defaultValue</code> - A default value to return if the next encoded value is a Null encoding.</dd>
<dt>Returns:</dt>
<dd>the value read from the provided byte source.</dd>
<dt>Throws:</dt>
<dd><code><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></code> - if the value fails to decode is not of the expected type,</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readUUID(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">
<h3>readUUID</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/UUID.html" title="class or interface in java.util" class="external-link">UUID</a></span>&nbsp;<span class="element-name">readUUID</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state)</span>
              throws <span class="exceptions"><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../StreamDecoder.html#readUUID(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">StreamDecoder</a></code></span></div>
<div class="block">Reads an encoded <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> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.  The operation fails if the next encoded type is
 not what was expected.  If the caller wishes to recover from failed decode attempt they should
 make a note of the current read position and reset the input to make a further read attempt.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../StreamDecoder.html#readUUID(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">readUUID</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</a></code></dd>
<dt>Parameters:</dt>
<dd><code>stream</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> where the read operation takes place.</dd>
<dd><code>state</code> - The <a href="../DecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>DecoderState</code></a> that the decoder can use when decoding.</dd>
<dt>Returns:</dt>
<dd>the value read from the provided byte source.</dd>
<dt>Throws:</dt>
<dd><code><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></code> - if the value fails to decode is not of the expected type,</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readMap(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">
<h3>readMap</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"><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;</span>&nbsp;<span class="element-name">readMap</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state)</span>
                       throws <span class="exceptions"><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../StreamDecoder.html#readMap(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">StreamDecoder</a></code></span></div>
<div class="block">Reads an encoded <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> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.  The operation fails if the next encoded type is
 not what was expected.  If the caller wishes to recover from failed decode attempt they should
 make a note of the current read position and reset the input to make a further read attempt.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../StreamDecoder.html#readMap(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">readMap</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</a></code></dd>
<dt>Type Parameters:</dt>
<dd><code>K</code> - The key type for the map that is being read.</dd>
<dd><code>V</code> - The value type for the map that is being read.</dd>
<dt>Parameters:</dt>
<dd><code>stream</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> where the read operation takes place.</dd>
<dd><code>state</code> - The <a href="../DecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>DecoderState</code></a> that the decoder can use when decoding.</dd>
<dt>Returns:</dt>
<dd>the value read from the provided byte source.</dd>
<dt>Throws:</dt>
<dd><code><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></code> - if the value fails to decode is not of the expected type,</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readList(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">
<h3>readList</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="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;V&gt;</span>&nbsp;<span class="element-name">readList</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream,
 <a href="../StreamDecoderState.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoderState</a>&nbsp;state)</span>
                     throws <span class="exceptions"><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../StreamDecoder.html#readList(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">StreamDecoder</a></code></span></div>
<div class="block">Reads an encoded <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> value from the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> assuming that the
 next value in the byte stream is that type.  The operation fails if the next encoded type is
 not what was expected.  If the caller wishes to recover from failed decode attempt they should
 make a note of the current read position and reset the input to make a further read attempt.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../StreamDecoder.html#readList(java.io.InputStream,org.apache.qpid.protonj2.codec.StreamDecoderState)">readList</a></code>&nbsp;in interface&nbsp;<code><a href="../StreamDecoder.html" title="interface in org.apache.qpid.protonj2.codec">StreamDecoder</a></code></dd>
<dt>Type Parameters:</dt>
<dd><code>V</code> - The value type for the list that is being read.</dd>
<dt>Parameters:</dt>
<dd><code>stream</code> - The <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> where the read operation takes place.</dd>
<dd><code>state</code> - The <a href="../DecoderState.html" title="interface in org.apache.qpid.protonj2.codec"><code>DecoderState</code></a> that the decoder can use when decoding.</dd>
<dt>Returns:</dt>
<dd>the value read from the provided byte source.</dd>
<dt>Throws:</dt>
<dd><code><a href="../DecodeException.html" title="class in org.apache.qpid.protonj2.codec">DecodeException</a></code> - if the value fails to decode is not of the expected type,</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>
