<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>ProtonByteArrayBuffer (Qpid ProtonJ2 Parent 1.0.0-M19 API)</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<meta name="description" content="declaration: package: org.apache.qpid.protonj2.buffer.impl, class: ProtonByteArrayBuffer">
<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/ProtonByteArrayBuffer.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><a href="#field-summary">Field</a>&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><a href="#field-detail">Field</a>&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 ProtonByteArrayBuffer" class="title">Class ProtonByteArrayBuffer</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.ProtonByteArrayBuffer</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="../ProtonBufferComponent.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferComponent</a></code>, <code><a href="../ProtonBufferComponentAccessor.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferComponentAccessor</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">ProtonByteArrayBuffer</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="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>, <a href="../ProtonBufferComponent.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferComponent</a>, <a href="../ProtonBufferComponentAccessor.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferComponentAccessor</a></span></div>
<div class="block">An array based buffer implementation.</div>
</section>
<section class="summary">
<ul class="summary-list">
<!-- =========== FIELD SUMMARY =========== -->
<li>
<section class="field-summary" id="field-summary">
<h2>Field Summary</h2>
<div class="caption"><span>Fields</span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Field</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code>static final int</code></div>
<div class="col-second even-row-color"><code><a href="#DEFAULT_CAPACITY" class="member-name-link">DEFAULT_CAPACITY</a></code></div>
<div class="col-last even-row-color">
<div class="block">The default initial capacity used for the underlying byte array.</div>
</div>
<div class="col-first odd-row-color"><code>static final int</code></div>
<div class="col-second odd-row-color"><code><a href="#DEFAULT_MAXIMUM_CAPACITY" class="member-name-link">DEFAULT_MAXIMUM_CAPACITY</a></code></div>
<div class="col-last odd-row-color">
<div class="block">The default maximum capacity that this buffer can grow to.</div>
</div>
</div>
</section>
</li>
<!-- ======== CONSTRUCTOR SUMMARY ======== -->
<li>
<section class="constructor-summary" id="constructor-summary">
<h2>Constructor Summary</h2>
<div class="caption"><span>Constructors</span></div>
<div class="summary-table two-column-summary">
<div class="table-header col-first">Constructor</div>
<div class="table-header col-last">Description</div>
<div class="col-constructor-name even-row-color"><code><a href="#%3Cinit%3E()" class="member-name-link">ProtonByteArrayBuffer</a>()</code></div>
<div class="col-last even-row-color">
<div class="block">Creates a new <a href="ProtonByteArrayBuffer.html" title="class in org.apache.qpid.protonj2.buffer.impl"><code>ProtonByteArrayBuffer</code></a> instance that uses default configuration values for
 initial capacity and the maximum allowed capacity to which the underlying byte array will
 grow before errors will be thrown from operations that would expand the storage.</div>
</div>
<div class="col-constructor-name odd-row-color"><code><a href="#%3Cinit%3E(byte%5B%5D)" class="member-name-link">ProtonByteArrayBuffer</a><wbr>(byte[]&nbsp;backingArray)</code></div>
<div class="col-last odd-row-color">
<div class="block">Create a new proton byte buffer instance with given backing array whose
 size determines that largest the buffer can ever be.</div>
</div>
<div class="col-constructor-name even-row-color"><code><a href="#%3Cinit%3E(byte%5B%5D,int)" class="member-name-link">ProtonByteArrayBuffer</a><wbr>(byte[]&nbsp;backingArray,
 int&nbsp;implicitGrowthLimit)</code></div>
<div class="col-last even-row-color">
<div class="block">Create a new proton byte buffer instance with given backing array as the
 starting backing store and uses the provided max capacity value to control
 how large the buffer could ever grow.</div>
</div>
<div class="col-constructor-name odd-row-color"><code><a href="#%3Cinit%3E(byte%5B%5D,int,int)" class="member-name-link">ProtonByteArrayBuffer</a><wbr>(byte[]&nbsp;backingArray,
 int&nbsp;arrayOffset,
 int&nbsp;implicitGrowthLimit)</code></div>
<div class="col-last odd-row-color">
<div class="block">Create a new proton byte buffer instance with given backing array as the
 starting backing store and uses the provided max capacity value to control
 how large the buffer could ever grow.</div>
</div>
<div class="col-constructor-name even-row-color"><code><a href="#%3Cinit%3E(byte%5B%5D,int,int,int)" class="member-name-link">ProtonByteArrayBuffer</a><wbr>(byte[]&nbsp;backingArray,
 int&nbsp;arrayOffset,
 int&nbsp;capacity,
 int&nbsp;implicitGrowthLimit)</code></div>
<div class="col-last even-row-color">
<div class="block">Create a new proton byte buffer instance with given backing array as the
 starting backing store and uses the provided max capacity value to control
 how large the buffer could ever grow.</div>
</div>
<div class="col-constructor-name odd-row-color"><code><a href="#%3Cinit%3E(int)" class="member-name-link">ProtonByteArrayBuffer</a><wbr>(int&nbsp;initialCapacity)</code></div>
<div class="col-last odd-row-color">
<div class="block">Creates a new <a href="ProtonByteArrayBuffer.html" title="class in org.apache.qpid.protonj2.buffer.impl"><code>ProtonByteArrayBuffer</code></a> with the given initial capacity and uses the default
 value for the maximum capacity restriction.</div>
</div>
<div class="col-constructor-name even-row-color"><code><a href="#%3Cinit%3E(int,int)" class="member-name-link">ProtonByteArrayBuffer</a><wbr>(int&nbsp;initialCapacity,
 int&nbsp;implicitGrowthLimit)</code></div>
<div class="col-last even-row-color">
<div class="block">Creates a new <a href="ProtonByteArrayBuffer.html" title="class in org.apache.qpid.protonj2.buffer.impl"><code>ProtonByteArrayBuffer</code></a> with the given initial capacity and the given maximum
 capacity restriction.</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-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="ProtonByteArrayBuffer.html" title="class in org.apache.qpid.protonj2.buffer.impl">ProtonByteArrayBuffer</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#advanceReadOffset(int)" class="member-name-link">advanceReadOffset</a><wbr>(int&nbsp;amount)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Adjusts the current <a href="../ProtonBuffer.html#getReadOffset()"><code>ProtonBuffer.getReadOffset()</code></a> of this buffer by the specified <code>length</code>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ProtonByteArrayBuffer.html" title="class in org.apache.qpid.protonj2.buffer.impl">ProtonByteArrayBuffer</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#advanceWriteOffset(int)" class="member-name-link">advanceWriteOffset</a><wbr>(int&nbsp;amount)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Adjusts the current <a href="../ProtonBuffer.html#getWriteOffset()"><code>ProtonBuffer.getWriteOffset()</code></a> of this buffer by the specified <code>length</code>.</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()" class="member-name-link">bufferIterator</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Creates and returns a new <a href="../ProtonBufferIterator.html" title="interface in org.apache.qpid.protonj2.buffer"><code>ProtonBufferIterator</code></a> that iterates from the current
 read offset and continues until all readable bytes have 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="#bufferIterator(int,int)" class="member-name-link">bufferIterator</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 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><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="#bufferReverseIterator(int,int)" class="member-name-link">bufferReverseIterator</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 reverse 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>int</code></div>
<div class="col-second odd-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 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="#compact()" class="member-name-link">compact</a>()</code></div>
<div class="col-last even-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 odd-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 odd-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 odd-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 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="#componentCount()" class="member-name-link">componentCount</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 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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="ProtonByteArrayBuffer.html" title="class in org.apache.qpid.protonj2.buffer.impl">ProtonByteArrayBuffer</a></code></div>
<div class="col-second odd-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 odd-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 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="#copy(int,int,boolean)" class="member-name-link">copy</a><wbr>(int&nbsp;offset,
 int&nbsp;length,
 boolean&nbsp;readOnly)</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 copy of this buffer's sub-region.</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,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 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 byte array
 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,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 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="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 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,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 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="../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 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="#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 even-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 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="#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 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="#fill(byte)" class="member-name-link">fill</a><wbr>(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">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 odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../ProtonBufferComponent.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferComponent</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#first()" class="member-name-link">first</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 first component that this access object provides which resets the
 iteration state to the beginning.</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>long</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getNativeAddress()" class="member-name-link">getNativeAddress</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Gets the native address of the backing buffer if one exists otherwise returns 0.</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="#getNativeReadAddress()" class="member-name-link">getNativeReadAddress</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Gets the native address where reads from this buffer component should start.</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="#getNativeWriteAddress()" class="member-name-link">getNativeWriteAddress</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Gets the native address where write to this buffer component should start.</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="#getReadableArray()" class="member-name-link">getReadableArray</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 readable array if one exists or throws an exception.</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="#getReadableArrayLength()" class="member-name-link">getReadableArrayLength</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="#getReadableArrayOffset()" class="member-name-link">getReadableArrayOffset</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="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></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getReadableBuffer()" class="member-name-link">getReadableBuffer</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 readable array if one exists or throws an exception.</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="#getReadableBytes()" class="member-name-link">getReadableBytes</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 readable bytes in the buffer safely regards of
 the actual memory backing this component.</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>byte[]</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getWritableArray()" class="member-name-link">getWritableArray</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 writable array if one exists or throws an exception.</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="#getWritableArrayLength()" class="member-name-link">getWritableArrayLength</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="#getWritableArrayOffset()" class="member-name-link">getWritableArrayOffset</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="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></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getWritableBuffer()" class="member-name-link">getWritableBuffer</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 writable <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> if one exists or throws an exception.</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="#getWritableBytes()" class="member-name-link">getWritableBytes</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 bytes in the buffer safely regards of
 the actual memory backing this component.</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="#getWriteOffset()" class="member-name-link">getWriteOffset</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="#hashCode()" class="member-name-link">hashCode</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="#hasReadbleArray()" class="member-name-link">hasReadbleArray</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="#hasWritableArray()" class="member-name-link">hasWritableArray</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="#implicitGrowthLimit()" class="member-name-link">implicitGrowthLimit</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 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><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="#implicitGrowthLimit(int)" class="member-name-link">implicitGrowthLimit</a><wbr>(int&nbsp;limit)</code></div>
<div class="col-last even-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 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="#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 odd-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 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="#isComposite()" class="member-name-link">isComposite</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="#isDirect()" class="member-name-link">isDirect</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="#isReadOnly()" class="member-name-link">isReadOnly</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="../ProtonBufferComponent.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferComponent</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#next()" class="member-name-link">next</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 next component that this access object provides which can be null if either
 the first method has never been called or the access of components has reached the end
 of the chain of buffer components that this access object is assigned to.</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="#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><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="#readBytes(byte%5B%5D,int,int)" class="member-name-link">readBytes</a><wbr>(byte[]&nbsp;destination,
 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">Read from this buffer, into the destination array, the given number of bytes.</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="#readBytes(java.nio.ByteBuffer)" class="member-name-link">readBytes</a><wbr>(<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)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Read from this buffer, into 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> This updates the read offset of this
 buffer and also the position of 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>.</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="../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="#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="../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="#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="../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="#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="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="../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="#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="../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="#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="../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="#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#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#copy()">copy</a>, <a href="../ProtonBuffer.html#copy(boolean)">copy</a>, <a href="../ProtonBuffer.html#copy(int,int)">copy</a>, <a href="../ProtonBuffer.html#ensureWritable(int)">ensureWritable</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#readSplit(int)">readSplit</a>, <a href="../ProtonBuffer.html#split()">split</a>, <a href="../ProtonBuffer.html#toString(java.nio.charset.Charset)">toString</a>, <a href="../ProtonBuffer.html#writeBytes(byte%5B%5D)">writeBytes</a>, <a href="../ProtonBuffer.html#writeBytes(java.nio.ByteBuffer)">writeBytes</a>, <a href="../ProtonBuffer.html#writeCharSequence(java.lang.CharSequence,java.nio.charset.Charset)">writeCharSequence</a>, <a href="../ProtonBuffer.html#writeSplit(int)">writeSplit</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.ProtonBufferComponentAccessor">Methods inherited from interface&nbsp;org.apache.qpid.protonj2.buffer.<a href="../ProtonBufferComponentAccessor.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferComponentAccessor</a></h3>
<code><a href="../ProtonBufferComponentAccessor.html#close()">close</a>, <a href="../ProtonBufferComponentAccessor.html#componentIterator()">componentIterator</a>, <a href="../ProtonBufferComponentAccessor.html#components()">components</a>, <a href="../ProtonBufferComponentAccessor.html#firstReadable()">firstReadable</a>, <a href="../ProtonBufferComponentAccessor.html#firstWritable()">firstWritable</a>, <a href="../ProtonBufferComponentAccessor.html#nextReadable()">nextReadable</a>, <a href="../ProtonBufferComponentAccessor.html#nextWritable()">nextWritable</a>, <a href="../ProtonBufferComponentAccessor.html#readableComponentIterator()">readableComponentIterator</a>, <a href="../ProtonBufferComponentAccessor.html#readableComponents()">readableComponents</a>, <a href="../ProtonBufferComponentAccessor.html#writableComponentIterator()">writableComponentIterator</a>, <a href="../ProtonBufferComponentAccessor.html#writableComponents()">writableComponents</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">
<!-- ============ FIELD DETAIL =========== -->
<li>
<section class="field-details" id="field-detail">
<h2>Field Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="DEFAULT_CAPACITY">
<h3>DEFAULT_CAPACITY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">DEFAULT_CAPACITY</span></div>
<div class="block">The default initial capacity used for the underlying byte array.</div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../../constant-values.html#org.apache.qpid.protonj2.buffer.impl.ProtonByteArrayBuffer.DEFAULT_CAPACITY">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="DEFAULT_MAXIMUM_CAPACITY">
<h3>DEFAULT_MAXIMUM_CAPACITY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">DEFAULT_MAXIMUM_CAPACITY</span></div>
<div class="block">The default maximum capacity that this buffer can grow to.</div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../../constant-values.html#org.apache.qpid.protonj2.buffer.impl.ProtonByteArrayBuffer.DEFAULT_MAXIMUM_CAPACITY">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
</ul>
</section>
</li>
<!-- ========= CONSTRUCTOR DETAIL ======== -->
<li>
<section class="constructor-details" id="constructor-detail">
<h2>Constructor Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="&lt;init&gt;()">
<h3>ProtonByteArrayBuffer</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="element-name">ProtonByteArrayBuffer</span>()</div>
<div class="block">Creates a new <a href="ProtonByteArrayBuffer.html" title="class in org.apache.qpid.protonj2.buffer.impl"><code>ProtonByteArrayBuffer</code></a> instance that uses default configuration values for
 initial capacity and the maximum allowed capacity to which the underlying byte array will
 grow before errors will be thrown from operations that would expand the storage.</div>
</section>
</li>
<li>
<section class="detail" id="&lt;init&gt;(int)">
<h3>ProtonByteArrayBuffer</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="element-name">ProtonByteArrayBuffer</span><wbr><span class="parameters">(int&nbsp;initialCapacity)</span></div>
<div class="block">Creates a new <a href="ProtonByteArrayBuffer.html" title="class in org.apache.qpid.protonj2.buffer.impl"><code>ProtonByteArrayBuffer</code></a> with the given initial capacity and uses the default
 value for the maximum capacity restriction.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>initialCapacity</code> - The initial size of the backing byte store.</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 given value is less than zero.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="&lt;init&gt;(int,int)">
<h3>ProtonByteArrayBuffer</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="element-name">ProtonByteArrayBuffer</span><wbr><span class="parameters">(int&nbsp;initialCapacity,
 int&nbsp;implicitGrowthLimit)</span></div>
<div class="block">Creates a new <a href="ProtonByteArrayBuffer.html" title="class in org.apache.qpid.protonj2.buffer.impl"><code>ProtonByteArrayBuffer</code></a> with the given initial capacity and the given maximum
 capacity restriction.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>initialCapacity</code> - The initial size of the backing byte store.</dd>
<dd><code>implicitGrowthLimit</code> - The maximum size the backing byte store is allowed to grow.</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 given value is less than zero or greater than the maximum.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="&lt;init&gt;(byte[])">
<h3>ProtonByteArrayBuffer</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="element-name">ProtonByteArrayBuffer</span><wbr><span class="parameters">(byte[]&nbsp;backingArray)</span></div>
<div class="block">Create a new proton byte buffer instance with given backing array whose
 size determines that largest the buffer can ever be.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>backingArray</code> - The byte array that will back the buffer instance</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="&lt;init&gt;(byte[],int)">
<h3>ProtonByteArrayBuffer</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="element-name">ProtonByteArrayBuffer</span><wbr><span class="parameters">(byte[]&nbsp;backingArray,
 int&nbsp;implicitGrowthLimit)</span></div>
<div class="block">Create a new proton byte buffer instance with given backing array as the
 starting backing store and uses the provided max capacity value to control
 how large the buffer could ever grow.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>backingArray</code> - The byte array that will back the buffer instance</dd>
<dd><code>implicitGrowthLimit</code> - The maximum to which this buffer can grow implicitly (without calls to ensureWritable).</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="&lt;init&gt;(byte[],int,int)">
<h3>ProtonByteArrayBuffer</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="element-name">ProtonByteArrayBuffer</span><wbr><span class="parameters">(byte[]&nbsp;backingArray,
 int&nbsp;arrayOffset,
 int&nbsp;implicitGrowthLimit)</span></div>
<div class="block">Create a new proton byte buffer instance with given backing array as the
 starting backing store and uses the provided max capacity value to control
 how large the buffer could ever grow.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>backingArray</code> - The byte array that will back the buffer instance</dd>
<dd><code>arrayOffset</code> - The offset into the backing array where the buffer starts.</dd>
<dd><code>implicitGrowthLimit</code> - The maximum to which this buffer can grow implicitly (without calls to ensureWritable).</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="&lt;init&gt;(byte[],int,int,int)">
<h3>ProtonByteArrayBuffer</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="element-name">ProtonByteArrayBuffer</span><wbr><span class="parameters">(byte[]&nbsp;backingArray,
 int&nbsp;arrayOffset,
 int&nbsp;capacity,
 int&nbsp;implicitGrowthLimit)</span></div>
<div class="block">Create a new proton byte buffer instance with given backing array as the
 starting backing store and uses the provided max capacity value to control
 how large the buffer could ever grow.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>backingArray</code> - The byte array that will back the buffer instance</dd>
<dd><code>arrayOffset</code> - The offset into the backing array where the buffer starts.</dd>
<dd><code>capacity</code> - The capacity limit for this view of the provided backing array.</dd>
<dd><code>implicitGrowthLimit</code> - The maximum to which this buffer can grow implicitly (without calls to ensureWritable).</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="unwrap()">
<h3>unwrap</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">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>Specified by:</dt>
<dd><code><a href="../ProtonBufferComponent.html#unwrap()">unwrap</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBufferComponent.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferComponent</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="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="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="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="convertToReadOnly()">
<h3>convertToReadOnly</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ProtonByteArrayBuffer.html" title="class in org.apache.qpid.protonj2.buffer.impl">ProtonByteArrayBuffer</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>Returns:</dt>
<dd>this buffer for use in chaining.</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="getReadableBytes()">
<h3>getReadableBytes</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">getReadableBytes</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBufferComponent.html#getReadableBytes()">ProtonBufferComponent</a></code></span></div>
<div class="block">Returns the number of readable bytes in the buffer safely regards of
 the actual memory backing this component.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBuffer.html#getReadableBytes()">getReadableBytes</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="../ProtonBufferComponent.html#getReadableBytes()">getReadableBytes</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBufferComponent.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferComponent</a></code></dd>
<dt>Returns:</dt>
<dd>the number of bytes available for reading from this buffer.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getWritableBytes()">
<h3>getWritableBytes</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">getWritableBytes</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBufferComponent.html#getWritableBytes()">ProtonBufferComponent</a></code></span></div>
<div class="block">Returns the number of writable bytes in the buffer safely regards of
 the actual memory backing this component.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBuffer.html#getWritableBytes()">getWritableBytes</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="../ProtonBufferComponent.html#getWritableBytes()">getWritableBytes</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBufferComponent.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferComponent</a></code></dd>
<dt>Returns:</dt>
<dd>the number of bytes that can be written to this buffer before the limit is hit.</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="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="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</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>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="setReadOffset(int)">
<h3>setReadOffset</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">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>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="fill(byte)">
<h3>fill</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">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>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="split(int)">
<h3>split</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">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>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="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="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="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="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="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="copy(int,int,boolean)">
<h3>copy</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">copy</span><wbr><span class="parameters">(int&nbsp;offset,
 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>Parameters:</dt>
<dd><code>offset</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="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="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</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>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="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</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>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="readBytes(java.nio.ByteBuffer)">
<h3>readBytes</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">readBytes</span><wbr><span class="parameters">(<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)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBuffer.html#readBytes(java.nio.ByteBuffer)">ProtonBuffer</a></code></span></div>
<div class="block">Read from this buffer, into 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> This updates the read offset of this
 buffer and also the position of 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>.
 <p>
 Note: the behavior is undefined if the given <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> is an alias for the memory in this buffer.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBuffer.html#readBytes(java.nio.ByteBuffer)">readBytes</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>destination</code> - The <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> to write into.</dd>
<dt>Returns:</dt>
<dd>this buffer for using in call chaining.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readBytes(byte[],int,int)">
<h3>readBytes</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">readBytes</span><wbr><span class="parameters">(byte[]&nbsp;destination,
 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#readBytes(byte%5B%5D,int,int)">ProtonBuffer</a></code></span></div>
<div class="block">Read from this buffer, into the destination array, the given number of bytes.
 This updates the read offset of this buffer by the length argument.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBuffer.html#readBytes(byte%5B%5D,int,int)">readBytes</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>destination</code> - The byte array to write into.</dd>
<dd><code>offset</code> - Position in the <code>destination</code> to where bytes should be written from this buffer.</dd>
<dd><code>length</code> - The number of bytes to copy.</dd>
<dt>Returns:</dt>
<dd>This buffer.</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="../ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</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>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="ensureWritable(int,int,boolean)">
<h3>ensureWritable</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">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>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="compact()">
<h3>compact</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">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>Returns:</dt>
<dd>this buffer for using in call chaining.</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="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="first()">
<h3>first</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../ProtonBufferComponent.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferComponent</a></span>&nbsp;<span class="element-name">first</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBufferComponentAccessor.html#first()">ProtonBufferComponentAccessor</a></code></span></div>
<div class="block">Returns the first component that this access object provides which resets the
 iteration state to the beginning.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBufferComponentAccessor.html#first()">first</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBufferComponentAccessor.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferComponentAccessor</a></code></dd>
<dt>Returns:</dt>
<dd>the first component in the sequence of <a href="../ProtonBufferComponent.html" title="interface in org.apache.qpid.protonj2.buffer"><code>ProtonBufferComponent</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="next()">
<h3>next</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../ProtonBufferComponent.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferComponent</a></span>&nbsp;<span class="element-name">next</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBufferComponentAccessor.html#next()">ProtonBufferComponentAccessor</a></code></span></div>
<div class="block">Returns the next component that this access object provides which can be null if either
 the first method has never been called or the access of components has reached the end
 of the chain of buffer components that this access object is assigned to.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBufferComponentAccessor.html#next()">next</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBufferComponentAccessor.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferComponentAccessor</a></code></dd>
<dt>Returns:</dt>
<dd>the first component in the sequence of <a href="../ProtonBufferComponent.html" title="interface in org.apache.qpid.protonj2.buffer"><code>ProtonBufferComponent</code></a> instance.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="bufferIterator()">
<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>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBuffer.html#bufferIterator()">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 current
 read offset and continues until all readable bytes have 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()">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>Specified by:</dt>
<dd><code><a href="../ProtonBufferComponent.html#bufferIterator()">bufferIterator</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBufferComponent.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferComponent</a></code></dd>
<dt>Returns:</dt>
<dd>a new buffer iterator that iterates over the readable bytes.</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="hasReadbleArray()">
<h3>hasReadbleArray</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">hasReadbleArray</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBufferComponent.html#hasReadbleArray()">hasReadbleArray</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBufferComponent.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferComponent</a></code></dd>
<dt>Returns:</dt>
<dd>true if the component is backed by a byte array that has a readable portion.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="advanceReadOffset(int)">
<h3>advanceReadOffset</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ProtonByteArrayBuffer.html" title="class in org.apache.qpid.protonj2.buffer.impl">ProtonByteArrayBuffer</a></span>&nbsp;<span class="element-name">advanceReadOffset</span><wbr><span class="parameters">(int&nbsp;amount)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBuffer.html#advanceReadOffset(int)">ProtonBuffer</a></code></span></div>
<div class="block">Adjusts the current <a href="../ProtonBuffer.html#getReadOffset()"><code>ProtonBuffer.getReadOffset()</code></a> of this buffer by the specified <code>length</code>.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBuffer.html#advanceReadOffset(int)">advanceReadOffset</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="../ProtonBufferComponent.html#advanceReadOffset(int)">advanceReadOffset</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBufferComponent.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferComponent</a></code></dd>
<dt>Parameters:</dt>
<dd><code>amount</code> - the number of bytes to advance the read offset by.</dd>
<dt>Returns:</dt>
<dd>this ProtonBuffer for chaining.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getReadableArray()">
<h3>getReadableArray</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">byte[]</span>&nbsp;<span class="element-name">getReadableArray</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBufferComponent.html#getReadableArray()">ProtonBufferComponent</a></code></span></div>
<div class="block">Returns the readable array if one exists or throws an exception.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBufferComponent.html#getReadableArray()">getReadableArray</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBufferComponent.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferComponent</a></code></dd>
<dt>Returns:</dt>
<dd>the readable array that backs this buffer component.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getReadableArrayOffset()">
<h3>getReadableArrayOffset</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">getReadableArrayOffset</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBufferComponent.html#getReadableArrayOffset()">getReadableArrayOffset</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBufferComponent.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferComponent</a></code></dd>
<dt>Returns:</dt>
<dd>the offset into the readable array where the readable bytes begin.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getReadableArrayLength()">
<h3>getReadableArrayLength</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">getReadableArrayLength</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBufferComponent.html#getReadableArrayLength()">getReadableArrayLength</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBufferComponent.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferComponent</a></code></dd>
<dt>Returns:</dt>
<dd>the length of the readable array from the offset that is owned by this component..</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getReadableBuffer()">
<h3>getReadableBuffer</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/nio/ByteBuffer.html" title="class or interface in java.nio" class="external-link">ByteBuffer</a></span>&nbsp;<span class="element-name">getReadableBuffer</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBufferComponent.html#getReadableBuffer()">ProtonBufferComponent</a></code></span></div>
<div class="block">Returns the readable array if one exists or throws an exception.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBufferComponent.html#getReadableBuffer()">getReadableBuffer</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBufferComponent.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferComponent</a></code></dd>
<dt>Returns:</dt>
<dd>the readable array that backs this buffer component.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="advanceWriteOffset(int)">
<h3>advanceWriteOffset</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="ProtonByteArrayBuffer.html" title="class in org.apache.qpid.protonj2.buffer.impl">ProtonByteArrayBuffer</a></span>&nbsp;<span class="element-name">advanceWriteOffset</span><wbr><span class="parameters">(int&nbsp;amount)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBuffer.html#advanceWriteOffset(int)">ProtonBuffer</a></code></span></div>
<div class="block">Adjusts the current <a href="../ProtonBuffer.html#getWriteOffset()"><code>ProtonBuffer.getWriteOffset()</code></a> of this buffer by the specified <code>length</code>.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBuffer.html#advanceWriteOffset(int)">advanceWriteOffset</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="../ProtonBufferComponent.html#advanceWriteOffset(int)">advanceWriteOffset</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBufferComponent.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferComponent</a></code></dd>
<dt>Parameters:</dt>
<dd><code>amount</code> - the number of bytes to advance the write offset by.</dd>
<dt>Returns:</dt>
<dd>this ProtonBuffer for chaining.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="hasWritableArray()">
<h3>hasWritableArray</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">hasWritableArray</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBufferComponent.html#hasWritableArray()">hasWritableArray</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBufferComponent.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferComponent</a></code></dd>
<dt>Returns:</dt>
<dd>true if the component is backed by a byte array that has writable bytes.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getWritableArray()">
<h3>getWritableArray</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">byte[]</span>&nbsp;<span class="element-name">getWritableArray</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBufferComponent.html#getWritableArray()">ProtonBufferComponent</a></code></span></div>
<div class="block">Returns the writable array if one exists or throws an exception.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBufferComponent.html#getWritableArray()">getWritableArray</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBufferComponent.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferComponent</a></code></dd>
<dt>Returns:</dt>
<dd>the writable array that backs this buffer component.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getWritableArrayOffset()">
<h3>getWritableArrayOffset</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">getWritableArrayOffset</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBufferComponent.html#getWritableArrayOffset()">getWritableArrayOffset</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBufferComponent.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferComponent</a></code></dd>
<dt>Returns:</dt>
<dd>the offset into the writable array where the writable bytes begin.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getWritableArrayLength()">
<h3>getWritableArrayLength</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">getWritableArrayLength</span>()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBufferComponent.html#getWritableArrayLength()">getWritableArrayLength</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBufferComponent.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferComponent</a></code></dd>
<dt>Returns:</dt>
<dd>the length of the writable array from the offset that is owned by this component..</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getWritableBuffer()">
<h3>getWritableBuffer</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/nio/ByteBuffer.html" title="class or interface in java.nio" class="external-link">ByteBuffer</a></span>&nbsp;<span class="element-name">getWritableBuffer</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBufferComponent.html#getWritableBuffer()">ProtonBufferComponent</a></code></span></div>
<div class="block">Returns the writable <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> if one exists or throws an exception.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBufferComponent.html#getWritableBuffer()">getWritableBuffer</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBufferComponent.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferComponent</a></code></dd>
<dt>Returns:</dt>
<dd>the writable buffer that backs this buffer component.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getNativeAddress()">
<h3>getNativeAddress</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">getNativeAddress</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBufferComponent.html#getNativeAddress()">ProtonBufferComponent</a></code></span></div>
<div class="block">Gets the native address of the backing buffer if one exists otherwise returns 0.
 <p>
 The returned address is the base address for the memory region that back this buffer which
 should not be used for reads and write as the backing region could be larger and not all portions
 of the backing region might be owned by this buffer component. The caller should use the methods
 <a href="../ProtonBufferComponent.html#getNativeReadAddress()"><code>ProtonBufferComponent.getNativeReadAddress()</code></a> and <a href="../ProtonBufferComponent.html#getNativeWriteAddress()"><code>ProtonBufferComponent.getNativeWriteAddress()</code></a> which each use this method
 to compute where these value actually fall in the native memory region.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBufferComponent.html#getNativeAddress()">getNativeAddress</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBufferComponent.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferComponent</a></code></dd>
<dt>Returns:</dt>
<dd>The native memory address for the region backing this buffer, if any, otherwise 0.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getNativeReadAddress()">
<h3>getNativeReadAddress</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">getNativeReadAddress</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBufferComponent.html#getNativeReadAddress()">ProtonBufferComponent</a></code></span></div>
<div class="block">Gets the native address where reads from this buffer component should start.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBufferComponent.html#getNativeReadAddress()">getNativeReadAddress</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBufferComponent.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferComponent</a></code></dd>
<dt>Returns:</dt>
<dd>The native memory address where reads start, if any, otherwise 0.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getNativeWriteAddress()">
<h3>getNativeWriteAddress</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">getNativeWriteAddress</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../ProtonBufferComponent.html#getNativeWriteAddress()">ProtonBufferComponent</a></code></span></div>
<div class="block">Gets the native address where write to this buffer component should start.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../ProtonBufferComponent.html#getNativeWriteAddress()">getNativeWriteAddress</a></code>&nbsp;in interface&nbsp;<code><a href="../ProtonBufferComponent.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferComponent</a></code></dd>
<dt>Returns:</dt>
<dd>The native memory address where writing should start, if any, otherwise 0.</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="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; 2024 <a href="https://www.apache.org/">The Apache Software Foundation</a>. All rights reserved.</small></p>
</footer>
</div>
</div>
</body>
</html>
