<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>ProtonCompositeBufferImpl (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.buffer.impl, class: ProtonCompositeBufferImpl">
<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/ProtonCompositeBufferImpl.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.buffer.impl</a></div>
<h1 title="Class ProtonCompositeBufferImpl" class="title">Class ProtonCompositeBufferImpl</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"><a href="../../resource/SharedResource.html" title="class in org.apache.qpid.protonj2.resource">org.apache.qpid.protonj2.resource.SharedResource</a>&lt;<a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&gt;
<div class="inheritance">org.apache.qpid.protonj2.buffer.impl.ProtonCompositeBufferImpl</div>
</div>
</div>
<section class="class-description" id="class-description">
<dl class="notes">
<dt>All Implemented Interfaces:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/AutoCloseable.html" title="class or interface in java.lang" class="external-link">AutoCloseable</a></code>, <code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Comparable.html" title="class or interface in java.lang" class="external-link">Comparable</a>&lt;<a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&gt;</code>, <code><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></code>, <code><a href="../ProtonBufferAccessors.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferAccessors</a></code>, <code><a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></code>, <code><a href="../../resource/Resource.html" title="interface in org.apache.qpid.protonj2.resource">Resource</a>&lt;<a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&gt;</code></dd>
</dl>
<hr>
<div class="type-signature"><span class="modifiers">public final class </span><span class="element-name type-name-label">ProtonCompositeBufferImpl</span>
<span class="extends-implements">extends <a href="../../resource/SharedResource.html" title="class in org.apache.qpid.protonj2.resource">SharedResource</a>&lt;<a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&gt;
implements <a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></span></div>
<div class="block">The built in composite buffer 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(org.apache.qpid.protonj2.buffer.ProtonBufferAllocator)" class="member-name-link">ProtonCompositeBufferImpl</a><wbr>(<a href="../ProtonBufferAllocator.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferAllocator</a>&nbsp;allocator)</code></div>
<div class="col-last even-row-color">
<div class="block">Creates a new empty composite buffer.</div>
</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-tab1" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab1', 3)" class="table-tab">Static Methods</button><button id="method-summary-table-tab2" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab2', 3)" class="table-tab">Instance Methods</button><button id="method-summary-table-tab4" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab4', 3)" class="table-tab">Concrete Methods</button></div>
<div id="method-summary-table.tabpanel" role="tabpanel">
<div class="summary-table three-column-summary" aria-labelledby="method-summary-table-tab0">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Method</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../ProtonBufferAllocator.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferAllocator</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#allocator()" class="member-name-link">allocator</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#append(org.apache.qpid.protonj2.buffer.ProtonBuffer)" class="member-name-link">append</a><wbr>(<a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Appends the given buffer to this composite buffer if all the constraints on
 buffer composites are met, otherwise thrown an exception.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../ProtonBufferIterator.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferIterator</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#bufferIterator(int,int)" class="member-name-link">bufferIterator</a><wbr>(int&nbsp;offset,
 int&nbsp;length)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Creates and returns a new <a href="../ProtonBufferIterator.html" title="interface in org.apache.qpid.protonj2.buffer"><code>ProtonBufferIterator</code></a> that iterates from the given
 offset and continues until specified number of bytes has been traversed.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../ProtonBufferIterator.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferIterator</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#bufferReverseIterator(int,int)" class="member-name-link">bufferReverseIterator</a><wbr>(int&nbsp;offset,
 int&nbsp;length)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Creates and returns a new <a href="../ProtonBufferIterator.html" title="interface in org.apache.qpid.protonj2.buffer"><code>ProtonBufferIterator</code></a> that reverse iterates from the given
 offset and continues until specified number of bytes has been traversed.</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="#capacity()" class="member-name-link">capacity</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#compact()" class="member-name-link">compact</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Moves the readable portion of the buffer to the beginning of the underlying
 buffer storage and possibly makes additional bytes available for writes before
 a buffer expansion would occur via an <a href="../ProtonBuffer.html#ensureWritable(int)"><code>ProtonBuffer.ensureWritable(int)</code></a> call.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../ProtonBufferComponentAccessor.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferComponentAccessor</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#componentAccessor()" class="member-name-link">componentAccessor</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns a component access object that can be used to gain access to the constituent buffer components
 for use in IO operations or other lower level buffer operations that need to work on single compoents.</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="#componentCount()" class="member-name-link">componentCount</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns the number of constituent buffer components that are contained in this buffer instance
 which for a non-composite buffer will always be one (namely itself).</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#convertToReadOnly()" class="member-name-link">convertToReadOnly</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Converts this buffer instance to a read-only buffer, any write operation that is
 performed on this buffer following this call will fail.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#copy(int,int,boolean)" class="member-name-link">copy</a><wbr>(int&nbsp;index,
 int&nbsp;length,
 boolean&nbsp;readOnly)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns a copy of this buffer's sub-region.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#copyInto(int,byte%5B%5D,int,int)" class="member-name-link">copyInto</a><wbr>(int&nbsp;offset,
 byte[]&nbsp;destination,
 int&nbsp;destOffset,
 int&nbsp;length)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Copies the given number of bytes from this buffer into the specified target byte array
 starting at the given offset into this buffer.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#copyInto(int,java.nio.ByteBuffer,int,int)" class="member-name-link">copyInto</a><wbr>(int&nbsp;offset,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/nio/ByteBuffer.html" title="class or interface in java.nio" class="external-link">ByteBuffer</a>&nbsp;destination,
 int&nbsp;destOffset,
 int&nbsp;length)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Copies the given number of bytes from this buffer into the specified target <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/nio/ByteBuffer.html" title="class or interface in java.nio" class="external-link"><code>ByteBuffer</code></a>
 starting at the given offset into this buffer.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#copyInto(int,org.apache.qpid.protonj2.buffer.ProtonBuffer,int,int)" class="member-name-link">copyInto</a><wbr>(int&nbsp;offset,
 <a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;destination,
 int&nbsp;destOffset,
 int&nbsp;length)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Copies the given number of bytes from this buffer into the specified target <a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer"><code>ProtonBuffer</code></a>
 starting at the given offset into this buffer.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#create(org.apache.qpid.protonj2.buffer.ProtonBufferAllocator)" class="member-name-link">create</a><wbr>(<a href="../ProtonBufferAllocator.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferAllocator</a>&nbsp;allocator)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Create an empty <a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer"><code>ProtonCompositeBuffer</code></a> with the given allocator which
 will be used any time the buffer needs to allocate additional storage space
 for implicit write or explicit ensure writable calls.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#create(org.apache.qpid.protonj2.buffer.ProtonBufferAllocator,org.apache.qpid.protonj2.buffer.ProtonBuffer)" class="member-name-link">create</a><wbr>(<a href="../ProtonBufferAllocator.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferAllocator</a>&nbsp;allocator,
 <a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Create an empty <a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer"><code>ProtonCompositeBuffer</code></a> with the given allocator which
 will be used any time the buffer needs to allocate additional storage space
 for implicit write or explicit ensure writable calls.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#create(org.apache.qpid.protonj2.buffer.ProtonBufferAllocator,org.apache.qpid.protonj2.buffer.ProtonBuffer%5B%5D)" class="member-name-link">create</a><wbr>(<a href="../ProtonBufferAllocator.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferAllocator</a>&nbsp;allocator,
 <a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>[]&nbsp;buffers)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Create an empty <a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer"><code>ProtonCompositeBuffer</code></a> with the given allocator which
 will be used any time the buffer needs to allocate additional storage space
 for implicit write or explicit ensure writable calls.</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/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a>&lt;<a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#decomposeBuffer()" class="member-name-link">decomposeBuffer</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Splits the composite buffer up into a collection of buffers that comprise it and
 leaves this buffer in what is effectively a closed state.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#ensureWritable(int,int,boolean)" class="member-name-link">ensureWritable</a><wbr>(int&nbsp;size,
 int&nbsp;minimumGrowth,
 boolean&nbsp;allowCompaction)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Ensures that the requested number of bytes is available for write operations
 in the current buffer, growing the buffer if needed to meet the requested
 writable capacity.</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="#equals(java.lang.Object)" class="member-name-link">equals</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&nbsp;o)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#fill(byte)" class="member-name-link">fill</a><wbr>(byte&nbsp;value)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Assigns the given value to every byte in the buffer without respect for the
 buffer read or write offsets.</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="#getByte(int)" class="member-name-link">getByte</a><wbr>(int&nbsp;index)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Reads a single byte at the given index and returns it without modification to the target
 buffer read offset.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>char</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getChar(int)" class="member-name-link">getChar</a><wbr>(int&nbsp;index)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Gets a 2-byte char from the specified index, this method will not modify the read or write
 index.</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="#getInt(int)" class="member-name-link">getInt</a><wbr>(int&nbsp;index)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Gets a int from the specified index, this method will not modify the read or write
 index.</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="#getLong(int)" class="member-name-link">getLong</a><wbr>(int&nbsp;index)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Gets a long from the specified index, this method will not modify the read or write
 index.</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="#getReadOffset()" class="member-name-link">getReadOffset</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>short</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getShort(int)" class="member-name-link">getShort</a><wbr>(int&nbsp;index)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Gets a short from the specified index, this method will not modify the read or write
 index.</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="#getWriteOffset()" class="member-name-link">getWriteOffset</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#hashCode()" class="member-name-link">hashCode</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#implicitGrowthLimit()" class="member-name-link">implicitGrowthLimit</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns the limit assigned to this buffer if one was set which controls how
 large the capacity of the buffer can grow implicitly via write calls.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#implicitGrowthLimit(int)" class="member-name-link">implicitGrowthLimit</a><wbr>(int&nbsp;limit)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Configures the limit assigned to this buffer if one was set which controls how
 large the capacity of the buffer can grow implicitly via write calls.</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="#indexOf(byte,int,int)" class="member-name-link">indexOf</a><wbr>(byte&nbsp;needle,
 int&nbsp;offset,
 int&nbsp;length)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Starting from the given offset into this buffer, find the next offset (index) in the
 buffer where the given value is located or <code>-1</code> if the value is not found by the
 time the specified number of bytes has been searched.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#isComposite()" class="member-name-link">isComposite</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#isDirect()" class="member-name-link">isDirect</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#isReadOnly()" class="member-name-link">isReadOnly</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#readableComponentCount()" class="member-name-link">readableComponentCount</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns the number of readable constituent buffer components that are contained in this buffer
 instance which for a non-composite buffer will always be zero or one (namely itself).</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="#readByte()" class="member-name-link">readByte</a>()</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 byte from the buffer and advances the read index by one.</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="#readChar()" class="member-name-link">readChar</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Reads a character value from the buffer and advances the read index by four.</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="#readInt()" class="member-name-link">readInt</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Reads a integer value from the buffer and advances the read index by four.</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="#readLong()" class="member-name-link">readLong</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Reads a long value from the buffer and advances the read index by eight.</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="#readShort()" class="member-name-link">readShort</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Reads a short value from the buffer and advances the read index by two.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#releaseResourceOwnership()" class="member-name-link">releaseResourceOwnership</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/RuntimeException.html" title="class or interface in java.lang" class="external-link">RuntimeException</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#resourceIsClosedException()" class="member-name-link">resourceIsClosedException</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../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="#setByte(int,byte)" class="member-name-link">setByte</a><wbr>(int&nbsp;index,
 byte&nbsp;value)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets the byte value at the given write index in this buffer's backing data store.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setChar(int,char)" class="member-name-link">setChar</a><wbr>(int&nbsp;index,
 char&nbsp;value)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets the char value at the given write index in this buffer's backing data store.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../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="#setInt(int,int)" class="member-name-link">setInt</a><wbr>(int&nbsp;index,
 int&nbsp;value)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets the int value at the given write index in this buffer's backing data store.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setLong(int,long)" class="member-name-link">setLong</a><wbr>(int&nbsp;index,
 long&nbsp;value)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets the long value at the given write index in this buffer's backing data store.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setReadOffset(int)" class="member-name-link">setReadOffset</a><wbr>(int&nbsp;value)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets the read offset for this buffer.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setShort(int,short)" class="member-name-link">setShort</a><wbr>(int&nbsp;index,
 short&nbsp;value)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets the short value at the given write index in this buffer's backing data store.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setWriteOffset(int)" class="member-name-link">setWriteOffset</a><wbr>(int&nbsp;value)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets the write offset for this buffer.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#split(int)" class="member-name-link">split</a><wbr>(int&nbsp;splitOffset)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Splits this buffer at the given offset.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#splitComponentsCeil(int)" class="member-name-link">splitComponentsCeil</a><wbr>(int&nbsp;splitOffset)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Split this buffer returning a composite that consists of all the buffer components up to and including
 the buffer that contains the split offset, no buffer components are split.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#splitComponentsFloor(int)" class="member-name-link">splitComponentsFloor</a><wbr>(int&nbsp;splitOffset)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Split this buffer returning a composite that consists of all the buffer components that come before
 the buffer that contains the split offset, no buffer components are split.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#toString()" class="member-name-link">toString</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#transferFrom(java.nio.channels.FileChannel,long,int)" class="member-name-link">transferFrom</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/nio/channels/FileChannel.html" title="class or interface in java.nio.channels" class="external-link">FileChannel</a>&nbsp;channel,
 long&nbsp;position,
 int&nbsp;length)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Reads a sequence of bytes from the given channel into this buffer.</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="#transferFrom(java.nio.channels.ReadableByteChannel,int)" class="member-name-link">transferFrom</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/nio/channels/ReadableByteChannel.html" title="class or interface in java.nio.channels" class="external-link">ReadableByteChannel</a>&nbsp;channel,
 int&nbsp;length)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Reads a sequence of bytes from the given channel into this buffer.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected <a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#transferTheResource()" class="member-name-link">transferTheResource</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#transferTo(java.nio.channels.WritableByteChannel,int)" class="member-name-link">transferTo</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/nio/channels/WritableByteChannel.html" title="class or interface in java.nio.channels" class="external-link">WritableByteChannel</a>&nbsp;channel,
 int&nbsp;length)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Read from this buffer and write to the given channel.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#unwrap()" class="member-name-link">unwrap</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Return the underlying buffer object that backs this <a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer"><code>ProtonBuffer</code></a> instance, or self
 if there is no backing object.</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="#writableComponentCount()" class="member-name-link">writableComponentCount</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns the number of writable constituent buffer components that are contained in this buffer
 instance which for a non-composite buffer will always be zero or one (namely itself).</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#writeByte(byte)" class="member-name-link">writeByte</a><wbr>(byte&nbsp;value)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Writes a single byte to the buffer and advances the write index by one.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#writeBytes(byte%5B%5D,int,int)" class="member-name-link">writeBytes</a><wbr>(byte[]&nbsp;source,
 int&nbsp;offset,
 int&nbsp;length)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Writes into this buffer, the given number of bytes from the byte array.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#writeBytes(org.apache.qpid.protonj2.buffer.ProtonBuffer)" class="member-name-link">writeBytes</a><wbr>(<a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;source)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Writes into this buffer, all the readable bytes from the given buffer.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../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="#writeChar(char)" class="member-name-link">writeChar</a><wbr>(char&nbsp;value)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Writes a single character to the buffer and advances the write index by four.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#writeInt(int)" class="member-name-link">writeInt</a><wbr>(int&nbsp;value)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Writes a single integer to the buffer and advances the write index by four.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../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="#writeLong(long)" class="member-name-link">writeLong</a><wbr>(long&nbsp;value)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Writes a single long to the buffer and advances the write index by eight.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#writeShort(short)" class="member-name-link">writeShort</a><wbr>(short&nbsp;value)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Writes a single short to the buffer and advances the write index by two.</div>
</div>
</div>
</div>
</div>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-org.apache.qpid.protonj2.resource.SharedResource">Methods inherited from class&nbsp;org.apache.qpid.protonj2.resource.<a href="../../resource/SharedResource.html" title="class in org.apache.qpid.protonj2.resource">SharedResource</a></h3>
<code><a href="../../resource/SharedResource.html#acquire()">acquire</a>, <a href="../../resource/SharedResource.html#close()">close</a>, <a href="../../resource/SharedResource.html#isClosed()">isClosed</a>, <a href="../../resource/SharedResource.html#isShared()">isShared</a>, <a href="../../resource/SharedResource.html#transfer()">transfer</a></code></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#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#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#wait()" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#wait(long)" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#wait(long,int)" title="class or interface in java.lang" class="external-link">wait</a></code></div>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-org.apache.qpid.protonj2.buffer.ProtonBuffer">Methods inherited from interface&nbsp;org.apache.qpid.protonj2.buffer.<a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></h3>
<code><a href="../ProtonBuffer.html#bufferIterator()">bufferIterator</a>, <a href="../ProtonBuffer.html#bufferReverseIterator()">bufferReverseIterator</a>, <a href="../ProtonBuffer.html#clear()">clear</a>, <a href="../ProtonBuffer.html#close()">close</a>, <a href="../ProtonBuffer.html#compareTo(org.apache.qpid.protonj2.buffer.ProtonBuffer)">compareTo</a>, <a href="../ProtonBuffer.html#getReadableBytes()">getReadableBytes</a>, <a href="../ProtonBuffer.html#getWritableBytes()">getWritableBytes</a>, <a href="../ProtonBuffer.html#indexOf(byte)">indexOf</a>, <a href="../ProtonBuffer.html#isClosed()">isClosed</a>, <a href="../ProtonBuffer.html#isReadable()">isReadable</a>, <a href="../ProtonBuffer.html#isWritable()">isWritable</a>, <a href="../ProtonBuffer.html#readCharSequence(int,java.nio.charset.Charset)">readCharSequence</a>, <a href="../ProtonBuffer.html#toString(java.nio.charset.Charset)">toString</a>, <a href="../ProtonBuffer.html#writeCharSequence(java.lang.CharSequence,java.nio.charset.Charset)">writeCharSequence</a></code></div>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-org.apache.qpid.protonj2.buffer.ProtonBufferAccessors">Methods inherited from interface&nbsp;org.apache.qpid.protonj2.buffer.<a href="../ProtonBufferAccessors.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferAccessors</a></h3>
<code><a href="../ProtonBufferAccessors.html#getBoolean(int)">getBoolean</a>, <a href="../ProtonBufferAccessors.html#getDouble(int)">getDouble</a>, <a href="../ProtonBufferAccessors.html#getFloat(int)">getFloat</a>, <a href="../ProtonBufferAccessors.html#getUnsignedByte(int)">getUnsignedByte</a>, <a href="../ProtonBufferAccessors.html#getUnsignedInt(int)">getUnsignedInt</a>, <a href="../ProtonBufferAccessors.html#getUnsignedShort(int)">getUnsignedShort</a>, <a href="../ProtonBufferAccessors.html#readBoolean()">readBoolean</a>, <a href="../ProtonBufferAccessors.html#readDouble()">readDouble</a>, <a href="../ProtonBufferAccessors.html#readFloat()">readFloat</a>, <a href="../ProtonBufferAccessors.html#readUnsignedByte()">readUnsignedByte</a>, <a href="../ProtonBufferAccessors.html#readUnsignedInt()">readUnsignedInt</a>, <a href="../ProtonBufferAccessors.html#readUnsignedShort()">readUnsignedShort</a>, <a href="../ProtonBufferAccessors.html#setBoolean(int,boolean)">setBoolean</a>, <a href="../ProtonBufferAccessors.html#setDouble(int,double)">setDouble</a>, <a href="../ProtonBufferAccessors.html#setFloat(int,float)">setFloat</a>, <a href="../ProtonBufferAccessors.html#setUnsignedByte(int,int)">setUnsignedByte</a>, <a href="../ProtonBufferAccessors.html#setUnsignedInt(int,long)">setUnsignedInt</a>, <a href="../ProtonBufferAccessors.html#setUnsignedShort(int,int)">setUnsignedShort</a>, <a href="../ProtonBufferAccessors.html#writeBoolean(boolean)">writeBoolean</a>, <a href="../ProtonBufferAccessors.html#writeDouble(double)">writeDouble</a>, <a href="../ProtonBufferAccessors.html#writeFloat(float)">writeFloat</a>, <a href="../ProtonBufferAccessors.html#writeUnsignedByte(int)">writeUnsignedByte</a>, <a href="../ProtonBufferAccessors.html#writeUnsignedInt(long)">writeUnsignedInt</a>, <a href="../ProtonBufferAccessors.html#writeUnsignedShort(int)">writeUnsignedShort</a></code></div>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-org.apache.qpid.protonj2.buffer.ProtonCompositeBuffer">Methods inherited from interface&nbsp;org.apache.qpid.protonj2.buffer.<a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></h3>
<code><a href="../ProtonCompositeBuffer.html#advanceReadOffset(int)">advanceReadOffset</a>, <a href="../ProtonCompositeBuffer.html#advanceWriteOffset(int)">advanceWriteOffset</a>, <a href="../ProtonCompositeBuffer.html#copy()">copy</a>, <a href="../ProtonCompositeBuffer.html#copy(boolean)">copy</a>, <a href="../ProtonCompositeBuffer.html#copy(int,int)">copy</a>, <a href="../ProtonCompositeBuffer.html#ensureWritable(int)">ensureWritable</a>, <a href="../ProtonCompositeBuffer.html#readBytes(byte%5B%5D,int,int)">readBytes</a>, <a href="../ProtonCompositeBuffer.html#readBytes(java.nio.ByteBuffer)">readBytes</a>, <a href="../ProtonCompositeBuffer.html#readSplit(int)">readSplit</a>, <a href="../ProtonCompositeBuffer.html#split()">split</a>, <a href="../ProtonCompositeBuffer.html#writeBytes(byte%5B%5D)">writeBytes</a>, <a href="../ProtonCompositeBuffer.html#writeBytes(java.nio.ByteBuffer)">writeBytes</a>, <a href="../ProtonCompositeBuffer.html#writeSplit(int)">writeSplit</a></code></div>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-org.apache.qpid.protonj2.resource.Resource">Methods inherited from interface&nbsp;org.apache.qpid.protonj2.resource.<a href="../../resource/Resource.html" title="interface in org.apache.qpid.protonj2.resource">Resource</a></h3>
<code><a href="../../resource/Resource.html#transfer()">transfer</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;(org.apache.qpid.protonj2.buffer.ProtonBufferAllocator)">
<h3>ProtonCompositeBufferImpl</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="element-name">ProtonCompositeBufferImpl</span><wbr><span class="parameters">(<a href="../ProtonBufferAllocator.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferAllocator</a>&nbsp;allocator)</span></div>
<div class="block">Creates a new empty composite buffer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>allocator</code> - the allocator that created this composite buffer.</dd>
</dl>
</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="allocator()">
<h3>allocator</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../ProtonBufferAllocator.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferAllocator</a></span>&nbsp;<span class="element-name">allocator</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>this buffer's allocator which was assigned on create.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="isDirect()">
<h3>isDirect</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isDirect</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBuffer.html#isDirect()">isDirect</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></code></dd>
<dt>Returns:</dt>
<dd>true if the buffer is backed by native memory.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="convertToReadOnly()">
<h3>convertToReadOnly</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></span>&nbsp;<span class="element-name">convertToReadOnly</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBuffer.html#convertToReadOnly()">ProtonBuffer</a></code></span></div>
<div class="block">Converts this buffer instance to a read-only buffer, any write operation that is
 performed on this buffer following this call will fail.  A buffer cannot be made
 writable after this call.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBuffer.html#convertToReadOnly()">convertToReadOnly</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></code></dd>
<dt>Specified by:</dt>
<dd><code><a href="../ProtonCompositeBuffer.html#convertToReadOnly()">convertToReadOnly</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></code></dd>
<dt>Returns:</dt>
<dd>this buffer for use in chaining.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="implicitGrowthLimit()">
<h3>implicitGrowthLimit</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">implicitGrowthLimit</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBuffer.html#implicitGrowthLimit()">ProtonBuffer</a></code></span></div>
<div class="block">Returns the limit assigned to this buffer if one was set which controls how
 large the capacity of the buffer can grow implicitly via write calls. Once
 the limit is hit any write call that requires more capacity than is currently
 available will throw an exception instead of allocating more space.
 <p>
 When a capacity limit is hit the buffer can still be enlarged but must be
 done explicitly via the ensure writable APIs.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBuffer.html#implicitGrowthLimit()">implicitGrowthLimit</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></code></dd>
<dt>Returns:</dt>
<dd>the number of bytes this buffer can currently grow to..</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="implicitGrowthLimit(int)">
<h3>implicitGrowthLimit</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></span>&nbsp;<span class="element-name">implicitGrowthLimit</span><wbr><span class="parameters">(int&nbsp;limit)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBuffer.html#implicitGrowthLimit(int)">ProtonBuffer</a></code></span></div>
<div class="block">Configures the limit assigned to this buffer if one was set which controls how
 large the capacity of the buffer can grow implicitly via write calls. Once
 the limit is hit any write call that requires more capacity than is currently
 available will throw an exception instead of allocating more space.
 <p>
 When a capacity limit is hit the buffer can still be enlarged but must be
 done explicitly via the ensure writable APIs.
 <p>
 The growth limit set applies only to this buffer instance and is not carried
 over to a copied buffer of the split buffer created from any of the buffer
 split calls.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBuffer.html#implicitGrowthLimit(int)">implicitGrowthLimit</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></code></dd>
<dt>Specified by:</dt>
<dd><code><a href="../ProtonCompositeBuffer.html#implicitGrowthLimit(int)">implicitGrowthLimit</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></code></dd>
<dt>Parameters:</dt>
<dd><code>limit</code> - The limit to assign as the maximum capacity this buffer can grow</dd>
<dt>Returns:</dt>
<dd>this buffer for using in call chaining.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="fill(byte)">
<h3>fill</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></span>&nbsp;<span class="element-name">fill</span><wbr><span class="parameters">(byte&nbsp;value)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBuffer.html#fill(byte)">ProtonBuffer</a></code></span></div>
<div class="block">Assigns the given value to every byte in the buffer without respect for the
 buffer read or write offsets.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBuffer.html#fill(byte)">fill</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></code></dd>
<dt>Specified by:</dt>
<dd><code><a href="../ProtonCompositeBuffer.html#fill(byte)">fill</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></code></dd>
<dt>Parameters:</dt>
<dd><code>value</code> - The byte value to assign each byte in this buffer.</dd>
<dt>Returns:</dt>
<dd>this ProtonBuffer for chaining.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="isComposite()">
<h3>isComposite</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isComposite</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBuffer.html#isComposite()">isComposite</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></code></dd>
<dt>Returns:</dt>
<dd>true if the buffer is backed by one or more <a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer"><code>ProtonBuffer</code></a> instances.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="componentCount()">
<h3>componentCount</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">componentCount</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBuffer.html#componentCount()">ProtonBuffer</a></code></span></div>
<div class="block">Returns the number of constituent buffer components that are contained in this buffer instance
 which for a non-composite buffer will always be one (namely itself).  For a composite buffer this
 count is the total count of all buffers mapped to the composite.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBuffer.html#componentCount()">componentCount</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></code></dd>
<dt>Returns:</dt>
<dd>the number of buffers managed by this <a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer"><code>ProtonBuffer</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readableComponentCount()">
<h3>readableComponentCount</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">readableComponentCount</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBuffer.html#readableComponentCount()">ProtonBuffer</a></code></span></div>
<div class="block">Returns the number of readable constituent buffer components that are contained in this buffer
 instance which for a non-composite buffer will always be zero or one (namely itself). For a composite
 buffer this count is the total count of all buffers mapped to the composite which are readable.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBuffer.html#readableComponentCount()">readableComponentCount</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></code></dd>
<dt>Returns:</dt>
<dd>the number of readable buffers managed by this <a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer"><code>ProtonBuffer</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writableComponentCount()">
<h3>writableComponentCount</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">writableComponentCount</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBuffer.html#writableComponentCount()">ProtonBuffer</a></code></span></div>
<div class="block">Returns the number of writable constituent buffer components that are contained in this buffer
 instance which for a non-composite buffer will always be zero or one (namely itself). For a composite
 buffer this count is the total count of all buffers mapped to the composite which are writable.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBuffer.html#writableComponentCount()">writableComponentCount</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></code></dd>
<dt>Returns:</dt>
<dd>the number of writable buffer components managed by this <a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer"><code>ProtonBuffer</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="isReadOnly()">
<h3>isReadOnly</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isReadOnly</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBuffer.html#isReadOnly()">isReadOnly</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></code></dd>
<dt>Returns:</dt>
<dd>whether this buffer instance is read-only or not.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="capacity()">
<h3>capacity</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">capacity</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBuffer.html#capacity()">capacity</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></code></dd>
<dt>Returns:</dt>
<dd>the number of bytes this buffer can currently contain.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="unwrap()">
<h3>unwrap</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></span>&nbsp;<span class="element-name">unwrap</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBuffer.html#unwrap()">ProtonBuffer</a></code></span></div>
<div class="block">Return the underlying buffer object that backs this <a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer"><code>ProtonBuffer</code></a> instance, or self
 if there is no backing object.

 This method should be overridden in buffer abstraction when access to the underlying backing
 store is needed such as when wrapping pooled resources that need explicit release calls.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBuffer.html#unwrap()">unwrap</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></code></dd>
<dt>Returns:</dt>
<dd>an underlying buffer object or other backing store for this buffer.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getReadOffset()">
<h3>getReadOffset</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">getReadOffset</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBuffer.html#getReadOffset()">getReadOffset</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></code></dd>
<dt>Returns:</dt>
<dd>the current value of the read offset for this buffer.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setReadOffset(int)">
<h3>setReadOffset</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></span>&nbsp;<span class="element-name">setReadOffset</span><wbr><span class="parameters">(int&nbsp;value)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBuffer.html#setReadOffset(int)">ProtonBuffer</a></code></span></div>
<div class="block">Sets the read offset for this buffer.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBuffer.html#setReadOffset(int)">setReadOffset</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></code></dd>
<dt>Specified by:</dt>
<dd><code><a href="../ProtonCompositeBuffer.html#setReadOffset(int)">setReadOffset</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></code></dd>
<dt>Parameters:</dt>
<dd><code>value</code> - The offset into the buffer where the read offset should be positioned.</dd>
<dt>Returns:</dt>
<dd>this buffer for use in chaining.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getWriteOffset()">
<h3>getWriteOffset</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">getWriteOffset</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBuffer.html#getWriteOffset()">getWriteOffset</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></code></dd>
<dt>Returns:</dt>
<dd>the current value of the write offset for this buffer.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setWriteOffset(int)">
<h3>setWriteOffset</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></span>&nbsp;<span class="element-name">setWriteOffset</span><wbr><span class="parameters">(int&nbsp;value)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBuffer.html#setWriteOffset(int)">ProtonBuffer</a></code></span></div>
<div class="block">Sets the write offset for this buffer.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBuffer.html#setWriteOffset(int)">setWriteOffset</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></code></dd>
<dt>Specified by:</dt>
<dd><code><a href="../ProtonCompositeBuffer.html#setWriteOffset(int)">setWriteOffset</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></code></dd>
<dt>Parameters:</dt>
<dd><code>value</code> - The offset into the buffer where the write offset should be positioned.</dd>
<dt>Returns:</dt>
<dd>this buffer for use in chaining.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="compact()">
<h3>compact</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></span>&nbsp;<span class="element-name">compact</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBuffer.html#compact()">ProtonBuffer</a></code></span></div>
<div class="block">Moves the readable portion of the buffer to the beginning of the underlying
 buffer storage and possibly makes additional bytes available for writes before
 a buffer expansion would occur via an <a href="../ProtonBuffer.html#ensureWritable(int)"><code>ProtonBuffer.ensureWritable(int)</code></a> call.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBuffer.html#compact()">compact</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></code></dd>
<dt>Specified by:</dt>
<dd><code><a href="../ProtonCompositeBuffer.html#compact()">compact</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></code></dd>
<dt>Returns:</dt>
<dd>this buffer for using in call chaining.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="copyInto(int,byte[],int,int)">
<h3>copyInto</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">copyInto</span><wbr><span class="parameters">(int&nbsp;offset,
 byte[]&nbsp;destination,
 int&nbsp;destOffset,
 int&nbsp;length)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBuffer.html#copyInto(int,byte%5B%5D,int,int)">ProtonBuffer</a></code></span></div>
<div class="block">Copies the given number of bytes from this buffer into the specified target byte array
 starting at the given offset into this buffer.  The copied region is written into the
 target starting at the given offset and continues for the specified length of elements.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBuffer.html#copyInto(int,byte%5B%5D,int,int)">copyInto</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></code></dd>
<dt>Parameters:</dt>
<dd><code>offset</code> - The offset into this buffer where the copy begins from.</dd>
<dd><code>destination</code> - The destination byte array where the copied bytes are written.</dd>
<dd><code>destOffset</code> - The offset into the destination to begin writing the copied bytes.</dd>
<dd><code>length</code> - The number of bytes to copy into the destination.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="copyInto(int,java.nio.ByteBuffer,int,int)">
<h3>copyInto</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">copyInto</span><wbr><span class="parameters">(int&nbsp;offset,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/nio/ByteBuffer.html" title="class or interface in java.nio" class="external-link">ByteBuffer</a>&nbsp;destination,
 int&nbsp;destOffset,
 int&nbsp;length)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBuffer.html#copyInto(int,java.nio.ByteBuffer,int,int)">ProtonBuffer</a></code></span></div>
<div class="block">Copies the given number of bytes from this buffer into the specified target <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/nio/ByteBuffer.html" title="class or interface in java.nio" class="external-link"><code>ByteBuffer</code></a>
 starting at the given offset into this buffer.  The copied region is written into the
 target starting at the given offset and continues for the specified length of elements.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBuffer.html#copyInto(int,java.nio.ByteBuffer,int,int)">copyInto</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></code></dd>
<dt>Parameters:</dt>
<dd><code>offset</code> - The offset into this buffer where the copy begins from.</dd>
<dd><code>destination</code> - The destination <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/nio/ByteBuffer.html" title="class or interface in java.nio" class="external-link"><code>ByteBuffer</code></a> where the copied bytes are written.</dd>
<dd><code>destOffset</code> - The offset into the destination to begin writing the copied bytes.</dd>
<dd><code>length</code> - The number of bytes to copy into the destination.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="copyInto(int,org.apache.qpid.protonj2.buffer.ProtonBuffer,int,int)">
<h3>copyInto</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">copyInto</span><wbr><span class="parameters">(int&nbsp;offset,
 <a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;destination,
 int&nbsp;destOffset,
 int&nbsp;length)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBuffer.html#copyInto(int,org.apache.qpid.protonj2.buffer.ProtonBuffer,int,int)">ProtonBuffer</a></code></span></div>
<div class="block">Copies the given number of bytes from this buffer into the specified target <a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer"><code>ProtonBuffer</code></a>
 starting at the given offset into this buffer.  The copied region is written into the
 target starting at the given offset and continues for the specified length of elements.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBuffer.html#copyInto(int,org.apache.qpid.protonj2.buffer.ProtonBuffer,int,int)">copyInto</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></code></dd>
<dt>Parameters:</dt>
<dd><code>offset</code> - The offset into this buffer where the copy begins from.</dd>
<dd><code>destination</code> - The destination <a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer"><code>ProtonBuffer</code></a> where the copied bytes are written.</dd>
<dd><code>destOffset</code> - The offset into the destination to begin writing the copied bytes.</dd>
<dd><code>length</code> - The number of bytes to copy into the destination.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeBytes(byte[],int,int)">
<h3>writeBytes</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></span>&nbsp;<span class="element-name">writeBytes</span><wbr><span class="parameters">(byte[]&nbsp;source,
 int&nbsp;offset,
 int&nbsp;length)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBuffer.html#writeBytes(byte%5B%5D,int,int)">ProtonBuffer</a></code></span></div>
<div class="block">Writes into this buffer, the given number of bytes from the byte array. This updates the
 <a href="../ProtonBuffer.html#getWriteOffset()">ProtonBuffer.getWriteOffset()</a> of this buffer by the length argument. Implementations are
 recommended to specialize this method and provide a more efficient version.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBuffer.html#writeBytes(byte%5B%5D,int,int)">writeBytes</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></code></dd>
<dt>Specified by:</dt>
<dd><code><a href="../ProtonCompositeBuffer.html#writeBytes(byte%5B%5D,int,int)">writeBytes</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></code></dd>
<dt>Parameters:</dt>
<dd><code>source</code> - The byte array to read from.</dd>
<dd><code>offset</code> - The position in the <code>source</code> from where bytes should be written to this buffer.</dd>
<dd><code>length</code> - The number of bytes to copy.</dd>
<dt>Returns:</dt>
<dd>this buffer for using in call chaining.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeBytes(org.apache.qpid.protonj2.buffer.ProtonBuffer)">
<h3>writeBytes</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></span>&nbsp;<span class="element-name">writeBytes</span><wbr><span class="parameters">(<a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;source)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBuffer.html#writeBytes(org.apache.qpid.protonj2.buffer.ProtonBuffer)">ProtonBuffer</a></code></span></div>
<div class="block">Writes into this buffer, all the readable bytes from the given buffer. This updates the
 <a href="../ProtonBuffer.html#getWriteOffset()"><code>ProtonBuffer.getWriteOffset()</code></a> of this buffer, and the <a href="../ProtonBuffer.html#getReadOffset()"><code>ProtonBuffer.getReadOffset()</code></a> of the given buffer.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBuffer.html#writeBytes(org.apache.qpid.protonj2.buffer.ProtonBuffer)">writeBytes</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></code></dd>
<dt>Specified by:</dt>
<dd><code><a href="../ProtonCompositeBuffer.html#writeBytes(org.apache.qpid.protonj2.buffer.ProtonBuffer)">writeBytes</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></code></dd>
<dt>Parameters:</dt>
<dd><code>source</code> - The buffer to read from.</dd>
<dt>Returns:</dt>
<dd>This buffer.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="append(org.apache.qpid.protonj2.buffer.ProtonBuffer)">
<h3>append</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></span>&nbsp;<span class="element-name">append</span><wbr><span class="parameters">(<a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonCompositeBuffer.html#append(org.apache.qpid.protonj2.buffer.ProtonBuffer)">ProtonCompositeBuffer</a></code></span></div>
<div class="block">Appends the given buffer to this composite buffer if all the constraints on
 buffer composites are met, otherwise thrown an exception.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonCompositeBuffer.html#append(org.apache.qpid.protonj2.buffer.ProtonBuffer)">append</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></code></dd>
<dt>Parameters:</dt>
<dd><code>buffer</code> - The buffer to append to this composite collection of buffers.</dd>
<dt>Returns:</dt>
<dd>this composite buffer instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="decomposeBuffer()">
<h3>decomposeBuffer</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/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a>&lt;<a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&gt;</span>&nbsp;<span class="element-name">decomposeBuffer</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonCompositeBuffer.html#decomposeBuffer()">ProtonCompositeBuffer</a></code></span></div>
<div class="block">Splits the composite buffer up into a collection of buffers that comprise it and
 leaves this buffer in what is effectively a closed state.  The returned buffers are
 now the property of the caller who must ensure they are closed when no longer in use..</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonCompositeBuffer.html#decomposeBuffer()">decomposeBuffer</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></code></dd>
<dt>Returns:</dt>
<dd>the collection of buffers that comprised this composite buffer.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="ensureWritable(int,int,boolean)">
<h3>ensureWritable</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></span>&nbsp;<span class="element-name">ensureWritable</span><wbr><span class="parameters">(int&nbsp;size,
 int&nbsp;minimumGrowth,
 boolean&nbsp;allowCompaction)</span>
                                     throws <span class="exceptions"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/IndexOutOfBoundsException.html" title="class or interface in java.lang" class="external-link">IndexOutOfBoundsException</a>,
<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/IllegalArgumentException.html" title="class or interface in java.lang" class="external-link">IllegalArgumentException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBuffer.html#ensureWritable(int,int,boolean)">ProtonBuffer</a></code></span></div>
<div class="block">Ensures that the requested number of bytes is available for write operations
 in the current buffer, growing the buffer if needed to meet the requested
 writable capacity. This method will not alter the write offset but may change
 the value returned from the capacity method if new buffer space is allocated.
 If the buffer cannot create the required number of byte via compaction then
 the buffer will be grown by either the requested number of bytes or by the
 minimum allowed value specified.
 <p>
 This method allows buffer compaction as a strategy to reclaim already read
 space to make room for additional writes. This implies that a composite buffer
 can reuse already read buffers to extend the buffer's writable space by moving
 them to the end of the set of composite buffers and reseting their index values
 to make them fully writable.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBuffer.html#ensureWritable(int,int,boolean)">ensureWritable</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></code></dd>
<dt>Specified by:</dt>
<dd><code><a href="../ProtonCompositeBuffer.html#ensureWritable(int,int,boolean)">ensureWritable</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></code></dd>
<dt>Parameters:</dt>
<dd><code>size</code> - The number of bytes beyond the current write index needed.</dd>
<dd><code>minimumGrowth</code> - The minimum number of byte that the buffer can grow by</dd>
<dd><code>allowCompaction</code> - Can the buffer use compaction as a strategy to create more writable space.</dd>
<dt>Returns:</dt>
<dd>this buffer for using in call chaining.</dd>
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/IndexOutOfBoundsException.html" title="class or interface in java.lang" class="external-link">IndexOutOfBoundsException</a></code> - if the amount given would result in the buffer
         exceeding the maximum capacity for this buffer.</dd>
<dd><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/IllegalArgumentException.html" title="class or interface in java.lang" class="external-link">IllegalArgumentException</a></code> - if the amount given is less than zero.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="copy(int,int,boolean)">
<h3>copy</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></span>&nbsp;<span class="element-name">copy</span><wbr><span class="parameters">(int&nbsp;index,
 int&nbsp;length,
 boolean&nbsp;readOnly)</span>
                           throws <span class="exceptions"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/IllegalArgumentException.html" title="class or interface in java.lang" class="external-link">IllegalArgumentException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBuffer.html#copy(int,int,boolean)">ProtonBuffer</a></code></span></div>
<div class="block">Returns a copy of this buffer's sub-region.  Modifying the content of
 the returned buffer or this buffer does not affect each other at all.
 This method does not modify the value returned from <a href="../ProtonBuffer.html#getReadOffset()"><code>ProtonBuffer.getReadOffset()</code></a>
 or <a href="../ProtonBuffer.html#getWriteOffset()"><code>ProtonBuffer.getWriteOffset()</code></a> of this buffer.
 <p>
 If this buffer is read-only and the requested copy is also read-only the
 copy may be shallow and allow each buffer to share the same memory.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBuffer.html#copy(int,int,boolean)">copy</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></code></dd>
<dt>Specified by:</dt>
<dd><code><a href="../ProtonCompositeBuffer.html#copy(int,int,boolean)">copy</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></code></dd>
<dt>Parameters:</dt>
<dd><code>index</code> - The index in this buffer where the copy should begin</dd>
<dd><code>length</code> - The number of bytes to copy to the new buffer from this one.</dd>
<dd><code>readOnly</code> - Should the returned buffer be read-only or not.</dd>
<dt>Returns:</dt>
<dd>a new ProtonBuffer instance containing the copied bytes.</dd>
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/IllegalArgumentException.html" title="class or interface in java.lang" class="external-link">IllegalArgumentException</a></code> - if the offset or length given are out of bounds.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="split(int)">
<h3>split</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></span>&nbsp;<span class="element-name">split</span><wbr><span class="parameters">(int&nbsp;splitOffset)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBuffer.html#split(int)">ProtonBuffer</a></code></span></div>
<div class="block">Splits this buffer at the given offset.
 <p>
 This creates two independent buffers that can manage differing views of the same
 memory region or in the case of a composite buffer two buffers that take ownership
 of differing sections of the composite buffer range. For a composite buffer a single
 buffer might be split if the offset lays within its bounds but all others buffers
 are divided amongst the two split buffers.
 <p>
 If this buffer is a read-only buffer then the resulting split buffer will also be
 read-only.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBuffer.html#split(int)">split</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></code></dd>
<dt>Specified by:</dt>
<dd><code><a href="../ProtonCompositeBuffer.html#split(int)">split</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></code></dd>
<dt>Parameters:</dt>
<dd><code>splitOffset</code> - The offset in this buffer where the split should occur.</dd>
<dt>Returns:</dt>
<dd>A new buffer that owns the memory spanning the range given.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="splitComponentsFloor(int)">
<h3>splitComponentsFloor</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></span>&nbsp;<span class="element-name">splitComponentsFloor</span><wbr><span class="parameters">(int&nbsp;splitOffset)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonCompositeBuffer.html#splitComponentsFloor(int)">ProtonCompositeBuffer</a></code></span></div>
<div class="block">Split this buffer returning a composite that consists of all the buffer components that come before
 the buffer that contains the split offset, no buffer components are split. This allows for operations
 such as reclaiming read bytes from a buffer to reduce overall memory use.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonCompositeBuffer.html#splitComponentsFloor(int)">splitComponentsFloor</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></code></dd>
<dt>Parameters:</dt>
<dd><code>splitOffset</code> - The index into the buffer where the split should be performed.</dd>
<dt>Returns:</dt>
<dd>A <a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer"><code>ProtonCompositeBuffer</code></a> that owns all buffers that come before the buffer that holds given index.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="splitComponentsCeil(int)">
<h3>splitComponentsCeil</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></span>&nbsp;<span class="element-name">splitComponentsCeil</span><wbr><span class="parameters">(int&nbsp;splitOffset)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonCompositeBuffer.html#splitComponentsCeil(int)">ProtonCompositeBuffer</a></code></span></div>
<div class="block">Split this buffer returning a composite that consists of all the buffer components up to and including
 the buffer that contains the split offset, no buffer components are split.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonCompositeBuffer.html#splitComponentsCeil(int)">splitComponentsCeil</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></code></dd>
<dt>Parameters:</dt>
<dd><code>splitOffset</code> - The index into the buffer where the split should be performed.</dd>
<dt>Returns:</dt>
<dd>A <a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer"><code>ProtonCompositeBuffer</code></a> that owns all buffers up to and including the buffer that holds given index.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getByte(int)">
<h3>getByte</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">byte</span>&nbsp;<span class="element-name">getByte</span><wbr><span class="parameters">(int&nbsp;index)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBufferAccessors.html#getByte(int)">ProtonBufferAccessors</a></code></span></div>
<div class="block">Reads a single byte at the given index and returns it without modification to the target
 buffer read offset.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBufferAccessors.html#getByte(int)">getByte</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBufferAccessors.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferAccessors</a></code></dd>
<dt>Parameters:</dt>
<dd><code>index</code> - The index into the buffer where the value should be read.</dd>
<dt>Returns:</dt>
<dd>the value read from the given index.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getChar(int)">
<h3>getChar</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">char</span>&nbsp;<span class="element-name">getChar</span><wbr><span class="parameters">(int&nbsp;index)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBufferAccessors.html#getChar(int)">ProtonBufferAccessors</a></code></span></div>
<div class="block">Gets a 2-byte char from the specified index, this method will not modify the read or write
 index.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBufferAccessors.html#getChar(int)">getChar</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBufferAccessors.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferAccessors</a></code></dd>
<dt>Parameters:</dt>
<dd><code>index</code> - The index into the buffer where the value should be read.</dd>
<dt>Returns:</dt>
<dd>the value read from the given index.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getShort(int)">
<h3>getShort</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">short</span>&nbsp;<span class="element-name">getShort</span><wbr><span class="parameters">(int&nbsp;index)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBufferAccessors.html#getShort(int)">ProtonBufferAccessors</a></code></span></div>
<div class="block">Gets a short from the specified index, this method will not modify the read or write
 index.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBufferAccessors.html#getShort(int)">getShort</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBufferAccessors.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferAccessors</a></code></dd>
<dt>Parameters:</dt>
<dd><code>index</code> - The index into the buffer where the value should be read.</dd>
<dt>Returns:</dt>
<dd>the value read from the given index.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getInt(int)">
<h3>getInt</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">getInt</span><wbr><span class="parameters">(int&nbsp;index)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBufferAccessors.html#getInt(int)">ProtonBufferAccessors</a></code></span></div>
<div class="block">Gets a int from the specified index, this method will not modify the read or write
 index.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBufferAccessors.html#getInt(int)">getInt</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBufferAccessors.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferAccessors</a></code></dd>
<dt>Parameters:</dt>
<dd><code>index</code> - The index into the buffer where the value should be read.</dd>
<dt>Returns:</dt>
<dd>the value read from the given index.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getLong(int)">
<h3>getLong</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">getLong</span><wbr><span class="parameters">(int&nbsp;index)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBufferAccessors.html#getLong(int)">ProtonBufferAccessors</a></code></span></div>
<div class="block">Gets a long from the specified index, this method will not modify the read or write
 index.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBufferAccessors.html#getLong(int)">getLong</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBufferAccessors.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferAccessors</a></code></dd>
<dt>Parameters:</dt>
<dd><code>index</code> - The index into the buffer where the value should be read.</dd>
<dt>Returns:</dt>
<dd>the value read from the given index.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setByte(int,byte)">
<h3>setByte</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></span>&nbsp;<span class="element-name">setByte</span><wbr><span class="parameters">(int&nbsp;index,
 byte&nbsp;value)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBufferAccessors.html#setByte(int,byte)">ProtonBufferAccessors</a></code></span></div>
<div class="block">Sets the byte value at the given write index in this buffer's backing data store.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBufferAccessors.html#setByte(int,byte)">setByte</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBufferAccessors.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferAccessors</a></code></dd>
<dt>Parameters:</dt>
<dd><code>index</code> - The index to start the write from.</dd>
<dd><code>value</code> - The value to write at the given index.</dd>
<dt>Returns:</dt>
<dd>a reference to this ProtonBuffer for chaining.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setChar(int,char)">
<h3>setChar</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></span>&nbsp;<span class="element-name">setChar</span><wbr><span class="parameters">(int&nbsp;index,
 char&nbsp;value)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBufferAccessors.html#setChar(int,char)">ProtonBufferAccessors</a></code></span></div>
<div class="block">Sets the char value at the given write index in this buffer's backing data store.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBufferAccessors.html#setChar(int,char)">setChar</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBufferAccessors.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferAccessors</a></code></dd>
<dt>Parameters:</dt>
<dd><code>index</code> - The index to start the write from.</dd>
<dd><code>value</code> - The value to write at the given index.</dd>
<dt>Returns:</dt>
<dd>a reference to this ProtonBuffer for chaining.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setShort(int,short)">
<h3>setShort</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></span>&nbsp;<span class="element-name">setShort</span><wbr><span class="parameters">(int&nbsp;index,
 short&nbsp;value)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBufferAccessors.html#setShort(int,short)">ProtonBufferAccessors</a></code></span></div>
<div class="block">Sets the short value at the given write index in this buffer's backing data store.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBufferAccessors.html#setShort(int,short)">setShort</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBufferAccessors.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferAccessors</a></code></dd>
<dt>Parameters:</dt>
<dd><code>index</code> - The index to start the write from.</dd>
<dd><code>value</code> - The value to write at the given index.</dd>
<dt>Returns:</dt>
<dd>a reference to this ProtonBuffer for chaining.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setInt(int,int)">
<h3>setInt</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></span>&nbsp;<span class="element-name">setInt</span><wbr><span class="parameters">(int&nbsp;index,
 int&nbsp;value)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBufferAccessors.html#setInt(int,int)">ProtonBufferAccessors</a></code></span></div>
<div class="block">Sets the int value at the given write index in this buffer's backing data store.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBufferAccessors.html#setInt(int,int)">setInt</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBufferAccessors.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferAccessors</a></code></dd>
<dt>Parameters:</dt>
<dd><code>index</code> - The index to start the write from.</dd>
<dd><code>value</code> - The value to write at the given index.</dd>
<dt>Returns:</dt>
<dd>a reference to this ProtonBuffer for chaining.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setLong(int,long)">
<h3>setLong</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></span>&nbsp;<span class="element-name">setLong</span><wbr><span class="parameters">(int&nbsp;index,
 long&nbsp;value)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBufferAccessors.html#setLong(int,long)">ProtonBufferAccessors</a></code></span></div>
<div class="block">Sets the long value at the given write index in this buffer's backing data store.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBufferAccessors.html#setLong(int,long)">setLong</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBufferAccessors.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferAccessors</a></code></dd>
<dt>Parameters:</dt>
<dd><code>index</code> - The index to start the write from.</dd>
<dd><code>value</code> - The value to write at the given index.</dd>
<dt>Returns:</dt>
<dd>a reference to this ProtonBuffer for chaining.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readByte()">
<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>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBufferAccessors.html#readByte()">ProtonBufferAccessors</a></code></span></div>
<div class="block">Reads one byte from the buffer and advances the read index by one.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBufferAccessors.html#readByte()">readByte</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBufferAccessors.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferAccessors</a></code></dd>
<dt>Returns:</dt>
<dd>a single byte from the ProtonBuffer.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readChar()">
<h3>readChar</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">char</span>&nbsp;<span class="element-name">readChar</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBufferAccessors.html#readChar()">ProtonBufferAccessors</a></code></span></div>
<div class="block">Reads a character value from the buffer and advances the read index by four.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBufferAccessors.html#readChar()">readChar</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBufferAccessors.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferAccessors</a></code></dd>
<dt>Returns:</dt>
<dd>char value read from the buffer.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readShort()">
<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>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBufferAccessors.html#readShort()">ProtonBufferAccessors</a></code></span></div>
<div class="block">Reads a short value from the buffer and advances the read index by two.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBufferAccessors.html#readShort()">readShort</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBufferAccessors.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferAccessors</a></code></dd>
<dt>Returns:</dt>
<dd>short value read from the buffer.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readInt()">
<h3>readInt</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">readInt</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBufferAccessors.html#readInt()">ProtonBufferAccessors</a></code></span></div>
<div class="block">Reads a integer value from the buffer and advances the read index by four.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBufferAccessors.html#readInt()">readInt</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBufferAccessors.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferAccessors</a></code></dd>
<dt>Returns:</dt>
<dd>integer value read from the buffer.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readLong()">
<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>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBufferAccessors.html#readLong()">ProtonBufferAccessors</a></code></span></div>
<div class="block">Reads a long value from the buffer and advances the read index by eight.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBufferAccessors.html#readLong()">readLong</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBufferAccessors.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferAccessors</a></code></dd>
<dt>Returns:</dt>
<dd>long value read from the buffer.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeByte(byte)">
<h3>writeByte</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></span>&nbsp;<span class="element-name">writeByte</span><wbr><span class="parameters">(byte&nbsp;value)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBufferAccessors.html#writeByte(byte)">ProtonBufferAccessors</a></code></span></div>
<div class="block">Writes a single byte to the buffer and advances the write index by one.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBufferAccessors.html#writeByte(byte)">writeByte</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBufferAccessors.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferAccessors</a></code></dd>
<dt>Parameters:</dt>
<dd><code>value</code> - The byte to write into the buffer.</dd>
<dt>Returns:</dt>
<dd>this ProtonBuffer for chaining.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeChar(char)">
<h3>writeChar</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></span>&nbsp;<span class="element-name">writeChar</span><wbr><span class="parameters">(char&nbsp;value)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBufferAccessors.html#writeChar(char)">ProtonBufferAccessors</a></code></span></div>
<div class="block">Writes a single character to the buffer and advances the write index by four.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBufferAccessors.html#writeChar(char)">writeChar</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBufferAccessors.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferAccessors</a></code></dd>
<dt>Parameters:</dt>
<dd><code>value</code> - The char to write into the buffer.</dd>
<dt>Returns:</dt>
<dd>this ProtonBuffer for chaining.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeShort(short)">
<h3>writeShort</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></span>&nbsp;<span class="element-name">writeShort</span><wbr><span class="parameters">(short&nbsp;value)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBufferAccessors.html#writeShort(short)">ProtonBufferAccessors</a></code></span></div>
<div class="block">Writes a single short to the buffer and advances the write index by two.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBufferAccessors.html#writeShort(short)">writeShort</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBufferAccessors.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferAccessors</a></code></dd>
<dt>Parameters:</dt>
<dd><code>value</code> - The short to write into the buffer.</dd>
<dt>Returns:</dt>
<dd>this ProtonBuffer for chaining.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeInt(int)">
<h3>writeInt</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></span>&nbsp;<span class="element-name">writeInt</span><wbr><span class="parameters">(int&nbsp;value)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBufferAccessors.html#writeInt(int)">ProtonBufferAccessors</a></code></span></div>
<div class="block">Writes a single integer to the buffer and advances the write index by four.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBufferAccessors.html#writeInt(int)">writeInt</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBufferAccessors.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferAccessors</a></code></dd>
<dt>Parameters:</dt>
<dd><code>value</code> - The integer to write into the buffer.</dd>
<dt>Returns:</dt>
<dd>this ProtonBuffer for chaining.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="writeLong(long)">
<h3>writeLong</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></span>&nbsp;<span class="element-name">writeLong</span><wbr><span class="parameters">(long&nbsp;value)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBufferAccessors.html#writeLong(long)">ProtonBufferAccessors</a></code></span></div>
<div class="block">Writes a single long to the buffer and advances the write index by eight.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBufferAccessors.html#writeLong(long)">writeLong</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBufferAccessors.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferAccessors</a></code></dd>
<dt>Parameters:</dt>
<dd><code>value</code> - The long to write into the buffer.</dd>
<dt>Returns:</dt>
<dd>this ProtonBuffer for chaining.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="equals(java.lang.Object)">
<h3>equals</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">equals</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&nbsp;o)</span></div>
<dl class="notes">
<dt>Overrides:</dt>
<dd><code><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></code>&nbsp;in class&nbsp;<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></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="hashCode()">
<h3>hashCode</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">hashCode</span>()</div>
<dl class="notes">
<dt>Overrides:</dt>
<dd><code><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></code>&nbsp;in class&nbsp;<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></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="toString()">
<h3>toString</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">toString</span>()</div>
<dl class="notes">
<dt>Overrides:</dt>
<dd><code><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></code>&nbsp;in class&nbsp;<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></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="transferTo(java.nio.channels.WritableByteChannel,int)">
<h3>transferTo</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">transferTo</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/nio/channels/WritableByteChannel.html" title="class or interface in java.nio.channels" class="external-link">WritableByteChannel</a>&nbsp;channel,
 int&nbsp;length)</span>
               throws <span class="exceptions"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/IOException.html" title="class or interface in java.io" class="external-link">IOException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBuffer.html#transferTo(java.nio.channels.WritableByteChannel,int)">ProtonBuffer</a></code></span></div>
<div class="block">Read from this buffer and write to the given channel.
 <p>
 The number of bytes actually written to the channel are returned. No more than the given <code>length</code>
 of bytes, or the number of <a href="../ProtonBuffer.html#getReadableBytes()">readable bytes</a>, will be written to the channel,
 whichever is smaller. A channel that has a position marker, will be advanced by the number of bytes written.
 The <a href="../ProtonBuffer.html#getReadOffset()">read offset</a> of this buffer will also be advanced by the number of bytes
 written.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBuffer.html#transferTo(java.nio.channels.WritableByteChannel,int)">transferTo</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></code></dd>
<dt>Parameters:</dt>
<dd><code>channel</code> - The channel to write to.</dd>
<dd><code>length</code> - The maximum number of bytes to write.</dd>
<dt>Returns:</dt>
<dd>The actual number of bytes written, possibly zero.</dd>
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/IOException.html" title="class or interface in java.io" class="external-link">IOException</a></code> - If the write-operation on the channel failed for some reason.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="transferFrom(java.nio.channels.ReadableByteChannel,int)">
<h3>transferFrom</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">transferFrom</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/nio/channels/ReadableByteChannel.html" title="class or interface in java.nio.channels" class="external-link">ReadableByteChannel</a>&nbsp;channel,
 int&nbsp;length)</span>
                 throws <span class="exceptions"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/IOException.html" title="class or interface in java.io" class="external-link">IOException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBuffer.html#transferFrom(java.nio.channels.ReadableByteChannel,int)">ProtonBuffer</a></code></span></div>
<div class="block">Reads a sequence of bytes from the given channel into this buffer.
 <p>
 The method reads a given amount of bytes from the provided channel and returns the number of
 bytes actually read which can be zero or -1 if the channel has reached the end of stream state.
 <p>
 The length value given is a maximum limit however the code will adjust this if the number
 of writable bytes in this buffer is smaller (or zero) and the result will indicate how many
 bytes where actually read.  The write offset of this buffer will be advanced by the number
 of bytes read from the buffer as will the channel position index if one exists.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBuffer.html#transferFrom(java.nio.channels.ReadableByteChannel,int)">transferFrom</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></code></dd>
<dt>Parameters:</dt>
<dd><code>channel</code> - The readable byte channel where the bytes are read</dd>
<dd><code>length</code> - The maximum number of bytes to read from the channel</dd>
<dt>Returns:</dt>
<dd>The number of bytes read, possibly zero, or -1 if the channel has reached end-of-stream</dd>
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/IOException.html" title="class or interface in java.io" class="external-link">IOException</a></code> - if the read operation fails</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="transferFrom(java.nio.channels.FileChannel,long,int)">
<h3>transferFrom</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">transferFrom</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/nio/channels/FileChannel.html" title="class or interface in java.nio.channels" class="external-link">FileChannel</a>&nbsp;channel,
 long&nbsp;position,
 int&nbsp;length)</span>
                 throws <span class="exceptions"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/IOException.html" title="class or interface in java.io" class="external-link">IOException</a></span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBuffer.html#transferFrom(java.nio.channels.FileChannel,long,int)">ProtonBuffer</a></code></span></div>
<div class="block">Reads a sequence of bytes from the given channel into this buffer.
 <p>
 The method reads a given amount of bytes from the provided channel and returns the number of
 bytes actually read which can be zero or -1 if the channel has reached the end of stream state.
 <p>
 The length value given is a maximum limit however the code will adjust this if the number
 of writable bytes in this buffer is smaller (or zero) and the result will indicate how many
 bytes where actually read.  The write offset of this buffer will be advanced by the number
 of bytes read from the buffer, the channel will not have its position modified.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBuffer.html#transferFrom(java.nio.channels.FileChannel,long,int)">transferFrom</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></code></dd>
<dt>Parameters:</dt>
<dd><code>channel</code> - The File channel where the bytes are read</dd>
<dd><code>position</code> - The position in the channel where the read should begin</dd>
<dd><code>length</code> - The maximum number of bytes to read from the channel</dd>
<dt>Returns:</dt>
<dd>The number of bytes read, possibly zero, or -1 if the channel has reached end-of-stream</dd>
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/IOException.html" title="class or interface in java.io" class="external-link">IOException</a></code> - if the read operation fails</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="bufferIterator(int,int)">
<h3>bufferIterator</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../ProtonBufferIterator.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferIterator</a></span>&nbsp;<span class="element-name">bufferIterator</span><wbr><span class="parameters">(int&nbsp;offset,
 int&nbsp;length)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBuffer.html#bufferIterator(int,int)">ProtonBuffer</a></code></span></div>
<div class="block">Creates and returns a new <a href="../ProtonBufferIterator.html" title="interface in org.apache.qpid.protonj2.buffer"><code>ProtonBufferIterator</code></a> that iterates from the given
 offset and continues until specified number of bytes has been traversed. The source buffer
 read and write offsets are not modified by an iterator instance.
 <p>
 The caller must ensure that the source buffer lifetime extends beyond the lifetime of
 the returned <a href="../ProtonBufferIterator.html" title="interface in org.apache.qpid.protonj2.buffer"><code>ProtonBufferIterator</code></a>.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBuffer.html#bufferIterator(int,int)">bufferIterator</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></code></dd>
<dt>Parameters:</dt>
<dd><code>offset</code> - The offset into the buffer where iteration begins</dd>
<dd><code>length</code> - The number of bytes to iterate over.</dd>
<dt>Returns:</dt>
<dd>a new buffer iterator that iterates over the readable bytes.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="bufferReverseIterator(int,int)">
<h3>bufferReverseIterator</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../ProtonBufferIterator.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferIterator</a></span>&nbsp;<span class="element-name">bufferReverseIterator</span><wbr><span class="parameters">(int&nbsp;offset,
 int&nbsp;length)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBuffer.html#bufferReverseIterator(int,int)">ProtonBuffer</a></code></span></div>
<div class="block">Creates and returns a new <a href="../ProtonBufferIterator.html" title="interface in org.apache.qpid.protonj2.buffer"><code>ProtonBufferIterator</code></a> that reverse iterates from the given
 offset and continues until specified number of bytes has been traversed. The source buffer
 read and write offsets are not modified by an iterator instance.
 <p>
 The caller must ensure that the source buffer lifetime extends beyond the lifetime of
 the returned <a href="../ProtonBufferIterator.html" title="interface in org.apache.qpid.protonj2.buffer"><code>ProtonBufferIterator</code></a>.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBuffer.html#bufferReverseIterator(int,int)">bufferReverseIterator</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></code></dd>
<dt>Parameters:</dt>
<dd><code>offset</code> - The offset into the buffer where iteration begins</dd>
<dd><code>length</code> - The number of bytes to iterate over.</dd>
<dt>Returns:</dt>
<dd>a new buffer iterator that iterates over the readable bytes.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="indexOf(byte,int,int)">
<h3>indexOf</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">indexOf</span><wbr><span class="parameters">(byte&nbsp;needle,
 int&nbsp;offset,
 int&nbsp;length)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBuffer.html#indexOf(byte,int,int)">ProtonBuffer</a></code></span></div>
<div class="block">Starting from the given offset into this buffer, find the next offset (index) in the
 buffer where the given value is located or <code>-1</code> if the value is not found by the
 time the specified number of bytes has been searched. This method does not affect the read or
 write offset and can be called from any point in the buffer regardless of the current read or
 write offsets. The search bounds are that of the buffer's readable bytes meaning that the
 starting office cannot be less than the read offset and the length cannot cause the search
 to read past the readable bytes otherwise an <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/IndexOutOfBoundsException.html" title="class or interface in java.lang" class="external-link"><code>IndexOutOfBoundsException</code></a> will be thrown.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBuffer.html#indexOf(byte,int,int)">indexOf</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></code></dd>
<dt>Parameters:</dt>
<dd><code>needle</code> - The byte value to search for in the remaining buffer bytes.</dd>
<dd><code>offset</code> - The offset into the buffer where the search should begin from.</dd>
<dd><code>length</code> - The offset into the buffer where the search should begin from.</dd>
<dt>Returns:</dt>
<dd>the location in the buffer where the value was found or <code>-1</code> if not found.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="componentAccessor()">
<h3>componentAccessor</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../ProtonBufferComponentAccessor.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferComponentAccessor</a></span>&nbsp;<span class="element-name">componentAccessor</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBuffer.html#componentAccessor()">ProtonBuffer</a></code></span></div>
<div class="block">Returns a component access object that can be used to gain access to the constituent buffer components
 for use in IO operations or other lower level buffer operations that need to work on single compoents.
 <p>
 The general usage of the component access object should be within a try-with-resource
 block as follows:
 <pre><code>
   try (ProtonBufferComponentAccessor accessor = buffer.componentAccessor()) {
      for (ProtonBufferComponent component : accessor.readableComponents()) {
         // Access logic here....
      }
   }
 </code></pre></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBuffer.html#componentAccessor()">componentAccessor</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></code></dd>
<dt>Returns:</dt>
<dd>a component access object instance used to view the buffer internal components</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="create(org.apache.qpid.protonj2.buffer.ProtonBufferAllocator)">
<h3>create</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></span>&nbsp;<span class="element-name">create</span><wbr><span class="parameters">(<a href="../ProtonBufferAllocator.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferAllocator</a>&nbsp;allocator)</span></div>
<div class="block">Create an empty <a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer"><code>ProtonCompositeBuffer</code></a> with the given allocator which
 will be used any time the buffer needs to allocate additional storage space
 for implicit write or explicit ensure writable calls.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>allocator</code> - the allocator to use when expanding capacity</dd>
<dt>Returns:</dt>
<dd>a new <a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer"><code>ProtonCompositeBuffer</code></a> that uses the provided allocator</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="create(org.apache.qpid.protonj2.buffer.ProtonBufferAllocator,org.apache.qpid.protonj2.buffer.ProtonBuffer[])">
<h3>create</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></span>&nbsp;<span class="element-name">create</span><wbr><span class="parameters">(<a href="../ProtonBufferAllocator.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferAllocator</a>&nbsp;allocator,
 <a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>[]&nbsp;buffers)</span></div>
<div class="block">Create an empty <a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer"><code>ProtonCompositeBuffer</code></a> with the given allocator which
 will be used any time the buffer needs to allocate additional storage space
 for implicit write or explicit ensure writable calls.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>allocator</code> - the allocator to use when expanding capacity.</dd>
<dd><code>buffers</code> - the sequence of buffers to compose.</dd>
<dt>Returns:</dt>
<dd>a new <a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer"><code>ProtonCompositeBuffer</code></a> that uses the provided allocator</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="create(org.apache.qpid.protonj2.buffer.ProtonBufferAllocator,org.apache.qpid.protonj2.buffer.ProtonBuffer)">
<h3>create</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonCompositeBuffer</a></span>&nbsp;<span class="element-name">create</span><wbr><span class="parameters">(<a href="../ProtonBufferAllocator.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferAllocator</a>&nbsp;allocator,
 <a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer)</span></div>
<div class="block">Create an empty <a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer"><code>ProtonCompositeBuffer</code></a> with the given allocator which
 will be used any time the buffer needs to allocate additional storage space
 for implicit write or explicit ensure writable calls.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>allocator</code> - the allocator to use when expanding capacity.</dd>
<dd><code>buffer</code> - the buffers to compose.</dd>
<dt>Returns:</dt>
<dd>a new <a href="../ProtonCompositeBuffer.html" title="interface in org.apache.qpid.protonj2.buffer"><code>ProtonCompositeBuffer</code></a> that uses the provided allocator</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="releaseResourceOwnership()">
<h3>releaseResourceOwnership</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">releaseResourceOwnership</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../../resource/SharedResource.html#releaseResourceOwnership()">releaseResourceOwnership</a></code>&nbsp;in class&nbsp;<code><a href="../../resource/SharedResource.html" title="class in org.apache.qpid.protonj2.resource">SharedResource</a>&lt;<a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&gt;</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="transferTheResource()">
<h3>transferTheResource</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type"><a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></span>&nbsp;<span class="element-name">transferTheResource</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../../resource/SharedResource.html#transferTheResource()">transferTheResource</a></code>&nbsp;in class&nbsp;<code><a href="../../resource/SharedResource.html" title="class in org.apache.qpid.protonj2.resource">SharedResource</a>&lt;<a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&gt;</code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="resourceIsClosedException()">
<h3>resourceIsClosedException</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/RuntimeException.html" title="class or interface in java.lang" class="external-link">RuntimeException</a></span>&nbsp;<span class="element-name">resourceIsClosedException</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../../resource/SharedResource.html#resourceIsClosedException()">resourceIsClosedException</a></code>&nbsp;in class&nbsp;<code><a href="../../resource/SharedResource.html" title="class in org.apache.qpid.protonj2.resource">SharedResource</a>&lt;<a href="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&gt;</code></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>
