<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
<meta http-equiv="X-UA-Compatible" content="IE=9"/>
<meta name="generator" content="Doxygen 1.9.1"/>
<meta name="viewport" content="width=device-width, initial-scale=1"/>
<title>Proton DotNet: Apache.Qpid.Proton.Buffer.IProtonBuffer Interface Reference</title>
<link href="tabs.css" rel="stylesheet" type="text/css"/>
<script type="text/javascript" src="jquery.js"></script>
<script type="text/javascript" src="dynsections.js"></script>
<link href="search/search.css" rel="stylesheet" type="text/css"/>
<script type="text/javascript" src="search/searchdata.js"></script>
<script type="text/javascript" src="search/search.js"></script>
<link href="doxygen.css" rel="stylesheet" type="text/css" />
</head>
<body>
<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
<div id="titlearea">
<table cellspacing="0" cellpadding="0">
 <tbody>
 <tr style="height: 56px;">
  <td id="projectalign" style="padding-left: 0.5em;">
   <div id="projectname">Proton DotNet
   </div>
  </td>
 </tr>
 </tbody>
</table>
</div>
<!-- end header part -->
<!-- Generated by Doxygen 1.9.1 -->
<script type="text/javascript">
/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
var searchBox = new SearchBox("searchBox", "search",false,'Search','.html');
/* @license-end */
</script>
<script type="text/javascript" src="menudata.js"></script>
<script type="text/javascript" src="menu.js"></script>
<script type="text/javascript">
/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
$(function() {
  initMenu('',true,false,'search.php','Search');
  $(document).ready(function() { init_search(); });
});
/* @license-end */</script>
<div id="main-nav"></div>
<!-- window showing the filter options -->
<div id="MSearchSelectWindow"
     onmouseover="return searchBox.OnSearchSelectShow()"
     onmouseout="return searchBox.OnSearchSelectHide()"
     onkeydown="return searchBox.OnSearchSelectKey(event)">
</div>

<!-- iframe showing the search results (closed by default) -->
<div id="MSearchResultsWindow">
<iframe src="javascript:void(0)" frameborder="0" 
        name="MSearchResults" id="MSearchResults">
</iframe>
</div>

<div id="nav-path" class="navpath">
  <ul>
<li class="navelem"><a class="el" href="namespaceApache.html">Apache</a></li><li class="navelem"><a class="el" href="namespaceApache_1_1Qpid.html">Qpid</a></li><li class="navelem"><a class="el" href="namespaceApache_1_1Qpid_1_1Proton.html">Proton</a></li><li class="navelem"><a class="el" href="namespaceApache_1_1Qpid_1_1Proton_1_1Buffer.html">Buffer</a></li><li class="navelem"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a></li>  </ul>
</div>
</div><!-- top -->
<div class="header">
  <div class="summary">
<a href="#pub-methods">Public Member Functions</a> &#124;
<a href="#properties">Properties</a> &#124;
<a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer-members.html">List of all members</a>  </div>
  <div class="headertitle">
<div class="title">Apache.Qpid.Proton.Buffer.IProtonBuffer Interface Reference</div>  </div>
</div><!--header-->
<div class="contents">
<div class="dynheader">
Inheritance diagram for Apache.Qpid.Proton.Buffer.IProtonBuffer:</div>
<div class="dyncontent">
 <div class="center">
  <img src="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.png" usemap="#Apache.Qpid.Proton.Buffer.IProtonBuffer_map" alt=""/>
  <map id="Apache.Qpid.Proton.Buffer.IProtonBuffer_map" name="Apache.Qpid.Proton.Buffer.IProtonBuffer_map">
<area href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html" title="Interface for proton buffer primitive type accessors that can be used with custom types to extend or ..." alt="Apache.Qpid.Proton.Buffer.IProtonBufferAccessors" shape="rect" coords="948,0,1254,24"/>
<area href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonCompositeBuffer.html" title="A composite buffer is used to make a collection of other proton buffer instances appear as one cohesi..." alt="Apache.Qpid.Proton.Buffer.IProtonCompositeBuffer" shape="rect" coords="316,112,622,136"/>
<area href="classApache_1_1Qpid_1_1Proton_1_1Buffer_1_1ProtonByteBuffer.html" title="A proton buffer implementation that wraps a single heap allocated byte array and provides read and wr..." alt="Apache.Qpid.Proton.Buffer.ProtonByteBuffer" shape="rect" coords="632,112,938,136"/>
<area href="classApache_1_1Qpid_1_1Proton_1_1Buffer_1_1ProtonCompositeBuffer.html" title="A composite buffer contains zero, one or more proton buffer instances chained together to behave as i..." alt="Apache.Qpid.Proton.Buffer.ProtonCompositeBuffer" shape="rect" coords="316,168,622,192"/>
  </map>
</div></div>
<table class="memberdecls">
<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
Public Member Functions</h2></td></tr>
<tr class="memitem:aa4919f89324410a3d598c3413ad4c3fd"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#aa4919f89324410a3d598c3413ad4c3fd">Fill</a> (byte value)</td></tr>
<tr class="memdesc:aa4919f89324410a3d598c3413ad4c3fd"><td class="mdescLeft">&#160;</td><td class="mdescRight">Fill the buffer with the given byte value. This method does not respect the read offset nor the write offset but instead fills the entire backing buffer memory with the given value.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#aa4919f89324410a3d598c3413ad4c3fd">More...</a><br /></td></tr>
<tr class="separator:aa4919f89324410a3d598c3413ad4c3fd"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ab173585f0d8585926d4b516d9dc83568"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#ab173585f0d8585926d4b516d9dc83568">EnsureWritable</a> (long amount)</td></tr>
<tr class="memdesc:ab173585f0d8585926d4b516d9dc83568"><td class="mdescLeft">&#160;</td><td class="mdescRight">Requests that the buffer ensure that there is enough allocated internal capacity such that the given number of bytes can be written without requiring additional allocations and that this amount does not exceed any total capacity restrictions for this buffer.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#ab173585f0d8585926d4b516d9dc83568">More...</a><br /></td></tr>
<tr class="separator:ab173585f0d8585926d4b516d9dc83568"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a170b9b5f5e746734e498bf929a16549f"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#a170b9b5f5e746734e498bf929a16549f">Reset</a> ()</td></tr>
<tr class="memdesc:a170b9b5f5e746734e498bf929a16549f"><td class="mdescLeft">&#160;</td><td class="mdescRight">Resets the read and write offset values to zero.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#a170b9b5f5e746734e498bf929a16549f">More...</a><br /></td></tr>
<tr class="separator:a170b9b5f5e746734e498bf929a16549f"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a41a8a013dfa52854e15a197e60671d1d"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#a41a8a013dfa52854e15a197e60671d1d">CopyInto</a> (long srcPos, byte[] dest, long destPos, long length)</td></tr>
<tr class="memdesc:a41a8a013dfa52854e15a197e60671d1d"><td class="mdescLeft">&#160;</td><td class="mdescRight">Copies the given number of bytes from this buffer into the target byte buffer starting the read from the given position in this buffer and the write to at the given position in the destination buffer. The length parameter controls how many bytes are copied to the destination. This method does not modify the read or write offset values in this buffer.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#a41a8a013dfa52854e15a197e60671d1d">More...</a><br /></td></tr>
<tr class="separator:a41a8a013dfa52854e15a197e60671d1d"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a32c170ccd46b5fb32fbf88323932d50e"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#a32c170ccd46b5fb32fbf88323932d50e">CopyInto</a> (long srcPos, <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a> dest, long destPos, long length)</td></tr>
<tr class="memdesc:a32c170ccd46b5fb32fbf88323932d50e"><td class="mdescLeft">&#160;</td><td class="mdescRight">Copies the given number of bytes from this buffer into the target byte buffer starting the read from the given position in this buffer and the write to at the given position in the destination buffer. The length parameter controls how many bytes are copied to the destination. This method does not modify the read or write offset values in this buffer nor those of the destination buffer. The destination write index is an absolute index value unrelated to the write offset of the target.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#a32c170ccd46b5fb32fbf88323932d50e">More...</a><br /></td></tr>
<tr class="separator:a32c170ccd46b5fb32fbf88323932d50e"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a4e34ec6f249c3188a3ca11cf965f1a1f"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#a4e34ec6f249c3188a3ca11cf965f1a1f">Copy</a> ()</td></tr>
<tr class="memdesc:a4e34ec6f249c3188a3ca11cf965f1a1f"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns a copy of this buffer's readable bytes. Modifying the content of the returned buffer will not affect this buffers contents. The two buffers will maintain separate offsets. The returned copy has the write offset set to the length of the copy meaning that the entire copied region is read for reading.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#a4e34ec6f249c3188a3ca11cf965f1a1f">More...</a><br /></td></tr>
<tr class="separator:a4e34ec6f249c3188a3ca11cf965f1a1f"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a2aacd63bf925e46bfb10991b4a5670dd"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#a2aacd63bf925e46bfb10991b4a5670dd">Copy</a> (long index, long length)</td></tr>
<tr class="memdesc:a2aacd63bf925e46bfb10991b4a5670dd"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns a copy of this buffer's readable bytes. Modifying the content of the returned buffer will not affect this buffers contents. The two buffers will maintain separate offsets. The amount and start of the data to be copied is provided by the index and length arguments. The returned copy has the write offset set to the length of the copy meaning that the entire copied region is read for reading.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#a2aacd63bf925e46bfb10991b4a5670dd">More...</a><br /></td></tr>
<tr class="separator:a2aacd63bf925e46bfb10991b4a5670dd"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a4a53e9991dea44bac8a13757025401f0"><td class="memItemLeft" align="right" valign="top">string&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#a4a53e9991dea44bac8a13757025401f0">ToString</a> (Encoding encoding)</td></tr>
<tr class="memdesc:a4a53e9991dea44bac8a13757025401f0"><td class="mdescLeft">&#160;</td><td class="mdescRight">Coverts the readable bytes in this buffer into a string value using the Encoding value provided. The underlying read and write offset values are not modified as a result of this operation.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#a4a53e9991dea44bac8a13757025401f0">More...</a><br /></td></tr>
<tr class="separator:a4a53e9991dea44bac8a13757025401f0"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a48952f07b1d51891f76974b80c52df87"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#a48952f07b1d51891f76974b80c52df87">SkipBytes</a> (long amount)</td></tr>
<tr class="memdesc:a48952f07b1d51891f76974b80c52df87"><td class="mdescLeft">&#160;</td><td class="mdescRight">Advance the buffer read offset by the specified amount effectively skipping that number of bytes from being read.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#a48952f07b1d51891f76974b80c52df87">More...</a><br /></td></tr>
<tr class="separator:a48952f07b1d51891f76974b80c52df87"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:abbdc44cbc36ca9126dab0a8af935f9ce"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#abbdc44cbc36ca9126dab0a8af935f9ce">WriteBytes</a> (byte[] source)</td></tr>
<tr class="memdesc:abbdc44cbc36ca9126dab0a8af935f9ce"><td class="mdescLeft">&#160;</td><td class="mdescRight">Writes the contents of the given byte array into this buffer and advances the write offset by the number of bytes written.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#abbdc44cbc36ca9126dab0a8af935f9ce">More...</a><br /></td></tr>
<tr class="separator:abbdc44cbc36ca9126dab0a8af935f9ce"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a67567a96165c61ac62ebfe824005aefd"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#a67567a96165c61ac62ebfe824005aefd">WriteBytes</a> (byte[] source, long offset, long length)</td></tr>
<tr class="memdesc:a67567a96165c61ac62ebfe824005aefd"><td class="mdescLeft">&#160;</td><td class="mdescRight">Writes the contents of the given byte array into this buffer and advances the write offset by the number of bytes written.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#a67567a96165c61ac62ebfe824005aefd">More...</a><br /></td></tr>
<tr class="separator:a67567a96165c61ac62ebfe824005aefd"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:aa0784e8f5a446e90b9ae57f16e3283ba"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#aa0784e8f5a446e90b9ae57f16e3283ba">WriteBytes</a> (<a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a> source)</td></tr>
<tr class="memdesc:aa0784e8f5a446e90b9ae57f16e3283ba"><td class="mdescLeft">&#160;</td><td class="mdescRight">Transfers the bytes from the source buffer to this buffer starting at the current write offset and continues until the source buffer becomes unreadable. The write index of this buffer is increased by the number of bytes read from the source. The method also increases the read offset of the source by the same amount as was written.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#aa0784e8f5a446e90b9ae57f16e3283ba">More...</a><br /></td></tr>
<tr class="separator:aa0784e8f5a446e90b9ae57f16e3283ba"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a9e9bca6e31529ac544ff1240e837680a"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#a9e9bca6e31529ac544ff1240e837680a">Compact</a> ()</td></tr>
<tr class="memdesc:a9e9bca6e31529ac544ff1240e837680a"><td class="mdescLeft">&#160;</td><td class="mdescRight">Discards the read bytes, and moves the buffer contents to the beginning of the buffer.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#a9e9bca6e31529ac544ff1240e837680a">More...</a><br /></td></tr>
<tr class="separator:a9e9bca6e31529ac544ff1240e837680a"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a9260e7737c81b37f0c43f7d16bdba20f"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#a9260e7737c81b37f0c43f7d16bdba20f">Reclaim</a> ()</td></tr>
<tr class="memdesc:a9260e7737c81b37f0c43f7d16bdba20f"><td class="mdescLeft">&#160;</td><td class="mdescRight">Reclaims read buffer space and returns it to the operating system or other pooling mechanisms if those are in place, then compacts the remaining buffer contents. For a non-composite buffer this operation could consist of allocating a smaller buffer to house any remaining unread bytes and freeing the larger backing buffer in some cases or it may result in a no-op depending on the buffer implementation. For the composite buffer case this operation provides an API which allows for fully read buffer constituents to be released and returned to a memory pool or back to the O/S.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#a9260e7737c81b37f0c43f7d16bdba20f">More...</a><br /></td></tr>
<tr class="separator:a9260e7737c81b37f0c43f7d16bdba20f"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:aba3ce684d8bc18eff174454036aec4ef"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#aba3ce684d8bc18eff174454036aec4ef">ReadSplit</a> (long offset)</td></tr>
<tr class="memdesc:aba3ce684d8bc18eff174454036aec4ef"><td class="mdescLeft">&#160;</td><td class="mdescRight">Splits the buffer into two distinct buffers at the given index plus the current read offset. The returned buffer will retain the read offset and write offset of this buffer but will be truncated to match the capacity provided by the split index, which implies that they might both be set to the capacity if they were previously set beyond the split index. The returned buffer will set its read and write offsets to zero if they fell prior to the given index otherwise they will be truncated to match the new buffer capacity. Split buffers support the standard buffer operations including resizing to ensure writable regions which implies that a buffer resize on either will cause them to no longer reference the same underlying memory region. If buffer implementations implement pooling then they must ensure proper release of shared buffer regions once both buffers no longer reference them.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#aba3ce684d8bc18eff174454036aec4ef">More...</a><br /></td></tr>
<tr class="separator:aba3ce684d8bc18eff174454036aec4ef"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a5de1edd80e6b1d0ebc7b18845ecfc8b1"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#a5de1edd80e6b1d0ebc7b18845ecfc8b1">WriteSplit</a> (long offset)</td></tr>
<tr class="memdesc:a5de1edd80e6b1d0ebc7b18845ecfc8b1"><td class="mdescLeft">&#160;</td><td class="mdescRight">Splits the buffer into two distinct buffers at the given index plus the current write offset. The returned buffer will retain the read offset and write offset of this buffer but will be truncated to match the capacity provided by the split index, which implies that they might both be set to the capacity if they were previously set to the split index. The returned buffer will set its read and write offsets to zero if they fell prior to the given index otherwise they will be truncated to match the new buffer capacity. Split buffers support the standard buffer operations including resizing to ensure writable regions which implies that a buffer resize on either will cause them to no longer reference the same underlying memory region. If buffer implementations implement pooling then they must ensure proper release of shared buffer regions once both buffers no longer reference them.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#a5de1edd80e6b1d0ebc7b18845ecfc8b1">More...</a><br /></td></tr>
<tr class="separator:a5de1edd80e6b1d0ebc7b18845ecfc8b1"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:acae3a5f39a75855252ad922ca9c2065c"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#acae3a5f39a75855252ad922ca9c2065c">Split</a> ()</td></tr>
<tr class="memdesc:acae3a5f39a75855252ad922ca9c2065c"><td class="mdescLeft">&#160;</td><td class="mdescRight">Splits the buffer into two buffers at the write offset. The resulting buffer will comprise the read and readable portions of this buffer with the write offset and capacity set to the current write offset. This buffer will lose access to the split region and its read offset will be set to the current write offset. This buffer will also have its capacity reduced by the number of bytes in the returned buffer (i.e. the current number of read and readable bytes). Split buffers support the standard buffer operations including resizing to ensure writable regions which implies that a buffer resize on either will cause them to no longer reference the same underlying memory region. If buffer implementations implement pooling then they must ensure proper release of shared buffer regions once both buffers no longer reference them.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#acae3a5f39a75855252ad922ca9c2065c">More...</a><br /></td></tr>
<tr class="separator:acae3a5f39a75855252ad922ca9c2065c"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a4326c640d62c909fdd6ed24202add322"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#a4326c640d62c909fdd6ed24202add322">Split</a> (long index)</td></tr>
<tr class="memdesc:a4326c640d62c909fdd6ed24202add322"><td class="mdescLeft">&#160;</td><td class="mdescRight">Splits the buffer into two distinct buffers at the given index. The returned buffer will retain the read offset and write offset of this buffer but will be truncated to match the capacity provided by the split index, which implies that they might both be set to the capacity if they were previously set beyond the split index. The returned buffer will set its read and write offsets to zero if they fell prior to the given index otherwise they will be truncated to match the new buffer capacity. Split buffers support the standard buffer operations including resizing to ensure writable regions which implies that a buffer resize on either will cause them to no longer reference the same underlying memory region. If buffer implementations implement pooling then they must ensure proper release of shared buffer regions once both buffers no longer reference them.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#a4326c640d62c909fdd6ed24202add322">More...</a><br /></td></tr>
<tr class="separator:a4326c640d62c909fdd6ed24202add322"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a16128227e8ef3f6161f2d6b8f826140b"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#a16128227e8ef3f6161f2d6b8f826140b">ForEachReadableComponent</a> (in int index, in Func&lt; int, <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IReadableComponent.html">IReadableComponent</a>, bool &gt; processor)</td></tr>
<tr class="memdesc:a16128227e8ef3f6161f2d6b8f826140b"><td class="mdescLeft">&#160;</td><td class="mdescRight">Invokes the provided delegate for each readable component in this buffer and increments the provided index value for each invocation. The total number of buffers processed is returned to the caller. The delegate can stop processing at any time by returning false in which case this method will stop and return a negative value to indicate that processing stopped early and did not traverse all available components.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#a16128227e8ef3f6161f2d6b8f826140b">More...</a><br /></td></tr>
<tr class="separator:a16128227e8ef3f6161f2d6b8f826140b"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a01fc21814ec3dac24561c1a5713dba4f"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#a01fc21814ec3dac24561c1a5713dba4f">ForEachWritableComponent</a> (in int index, in Func&lt; int, <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IWritableComponent.html">IWritableComponent</a>, bool &gt; processor)</td></tr>
<tr class="memdesc:a01fc21814ec3dac24561c1a5713dba4f"><td class="mdescLeft">&#160;</td><td class="mdescRight">Invokes the provided delegate for each writable component in this buffer and increments the provided index value for each invocation. The total number of buffers processed is returned to the caller. The delegate can stop processing at any time by returning false in which case this method will stop and return a negative value to indicate that processing stopped early and did not traverse all available components.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#a01fc21814ec3dac24561c1a5713dba4f">More...</a><br /></td></tr>
<tr class="separator:a01fc21814ec3dac24561c1a5713dba4f"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="inherit_header pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors')"><img src="closed.png" alt="-"/>&#160;Public Member Functions inherited from <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html">Apache.Qpid.Proton.Buffer.IProtonBufferAccessors</a></td></tr>
<tr class="memitem:a67f3bb2699b9d10174fb0588dd9c03d9 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memItemLeft" align="right" valign="top">bool&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a67f3bb2699b9d10174fb0588dd9c03d9">GetBoolean</a> (long index)</td></tr>
<tr class="memdesc:a67f3bb2699b9d10174fb0588dd9c03d9 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="mdescLeft">&#160;</td><td class="mdescRight">Reads a single byte from the given index and returns a boolean value indicating if the byte was zero (false) or greater than zero (true).  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a67f3bb2699b9d10174fb0588dd9c03d9">More...</a><br /></td></tr>
<tr class="separator:a67f3bb2699b9d10174fb0588dd9c03d9 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:abddb50f85a8ee9a4dc1c4388a0150e0c inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memItemLeft" align="right" valign="top">sbyte&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#abddb50f85a8ee9a4dc1c4388a0150e0c">GetByte</a> (long index)</td></tr>
<tr class="memdesc:abddb50f85a8ee9a4dc1c4388a0150e0c inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="mdescLeft">&#160;</td><td class="mdescRight">Reads a single signed byte from the given index and returns it.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#abddb50f85a8ee9a4dc1c4388a0150e0c">More...</a><br /></td></tr>
<tr class="separator:abddb50f85a8ee9a4dc1c4388a0150e0c inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a268b8d2564324fa7c4733eba13766457 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memItemLeft" align="right" valign="top">byte&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a268b8d2564324fa7c4733eba13766457">GetUnsignedByte</a> (long index)</td></tr>
<tr class="memdesc:a268b8d2564324fa7c4733eba13766457 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="mdescLeft">&#160;</td><td class="mdescRight">Reads a single unsigned byte from the given index and returns it.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a268b8d2564324fa7c4733eba13766457">More...</a><br /></td></tr>
<tr class="separator:a268b8d2564324fa7c4733eba13766457 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a494f8102bcc0a8f02fa2d8b1f83c8222 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memItemLeft" align="right" valign="top">char&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a494f8102bcc0a8f02fa2d8b1f83c8222">GetChar</a> (long index)</td></tr>
<tr class="memdesc:a494f8102bcc0a8f02fa2d8b1f83c8222 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="mdescLeft">&#160;</td><td class="mdescRight">Reads a single 2 byte char from the given index and returns it.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a494f8102bcc0a8f02fa2d8b1f83c8222">More...</a><br /></td></tr>
<tr class="separator:a494f8102bcc0a8f02fa2d8b1f83c8222 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ada1cfa2dcf757ec3e5d8643f9ecc5982 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memItemLeft" align="right" valign="top">short&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#ada1cfa2dcf757ec3e5d8643f9ecc5982">GetShort</a> (long index)</td></tr>
<tr class="memdesc:ada1cfa2dcf757ec3e5d8643f9ecc5982 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="mdescLeft">&#160;</td><td class="mdescRight">Reads a single 2 byte short from the given index and returns it.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#ada1cfa2dcf757ec3e5d8643f9ecc5982">More...</a><br /></td></tr>
<tr class="separator:ada1cfa2dcf757ec3e5d8643f9ecc5982 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:add33ded6eea6f3cfd431f401de714317 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memItemLeft" align="right" valign="top">ushort&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#add33ded6eea6f3cfd431f401de714317">GetUnsignedShort</a> (long index)</td></tr>
<tr class="memdesc:add33ded6eea6f3cfd431f401de714317 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="mdescLeft">&#160;</td><td class="mdescRight">Reads a single 2 byte unsigned short from the given index and returns it.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#add33ded6eea6f3cfd431f401de714317">More...</a><br /></td></tr>
<tr class="separator:add33ded6eea6f3cfd431f401de714317 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a27a3f9b8842d43071c2e3d45bd033677 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a27a3f9b8842d43071c2e3d45bd033677">GetInt</a> (long index)</td></tr>
<tr class="memdesc:a27a3f9b8842d43071c2e3d45bd033677 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="mdescLeft">&#160;</td><td class="mdescRight">Reads a single 4 byte int from the given index and returns it.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a27a3f9b8842d43071c2e3d45bd033677">More...</a><br /></td></tr>
<tr class="separator:a27a3f9b8842d43071c2e3d45bd033677 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a924e05f676c1c111f120565e5f432d06 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memItemLeft" align="right" valign="top">uint&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a924e05f676c1c111f120565e5f432d06">GetUnsignedInt</a> (long index)</td></tr>
<tr class="memdesc:a924e05f676c1c111f120565e5f432d06 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="mdescLeft">&#160;</td><td class="mdescRight">Reads a single 4 byte unsigned int from the given index and returns it.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a924e05f676c1c111f120565e5f432d06">More...</a><br /></td></tr>
<tr class="separator:a924e05f676c1c111f120565e5f432d06 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a9d73544ff8a7d76091d0e155a38bd619 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memItemLeft" align="right" valign="top">long&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a9d73544ff8a7d76091d0e155a38bd619">GetLong</a> (long index)</td></tr>
<tr class="memdesc:a9d73544ff8a7d76091d0e155a38bd619 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="mdescLeft">&#160;</td><td class="mdescRight">Reads a single 8 byte long from the given index and returns it.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a9d73544ff8a7d76091d0e155a38bd619">More...</a><br /></td></tr>
<tr class="separator:a9d73544ff8a7d76091d0e155a38bd619 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a8dc8290ef3cf39fc30349e0f1425d409 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memItemLeft" align="right" valign="top">ulong&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a8dc8290ef3cf39fc30349e0f1425d409">GetUnsignedLong</a> (long index)</td></tr>
<tr class="memdesc:a8dc8290ef3cf39fc30349e0f1425d409 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="mdescLeft">&#160;</td><td class="mdescRight">Reads a single 8 byte unsigned long from the given index and returns it.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a8dc8290ef3cf39fc30349e0f1425d409">More...</a><br /></td></tr>
<tr class="separator:a8dc8290ef3cf39fc30349e0f1425d409 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ab661f5eaf580454bdce1b1f496ccc5f7 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memItemLeft" align="right" valign="top">float&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#ab661f5eaf580454bdce1b1f496ccc5f7">GetFloat</a> (long index)</td></tr>
<tr class="memdesc:ab661f5eaf580454bdce1b1f496ccc5f7 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="mdescLeft">&#160;</td><td class="mdescRight">Reads a single 4 byte float from the given index and returns it.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#ab661f5eaf580454bdce1b1f496ccc5f7">More...</a><br /></td></tr>
<tr class="separator:ab661f5eaf580454bdce1b1f496ccc5f7 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:afc596b3498f5308102795afda5c506ef inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memItemLeft" align="right" valign="top">double&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#afc596b3498f5308102795afda5c506ef">GetDouble</a> (long index)</td></tr>
<tr class="memdesc:afc596b3498f5308102795afda5c506ef inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="mdescLeft">&#160;</td><td class="mdescRight">Reads a single 8 byte double from the given index and returns it.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#afc596b3498f5308102795afda5c506ef">More...</a><br /></td></tr>
<tr class="separator:afc596b3498f5308102795afda5c506ef inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ab9ac2b8383541a245555a69097401cf3 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#ab9ac2b8383541a245555a69097401cf3">SetByte</a> (long index, sbyte value)</td></tr>
<tr class="memdesc:ab9ac2b8383541a245555a69097401cf3 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="mdescLeft">&#160;</td><td class="mdescRight">Write the given byte value at the given location in the buffer backing store without modifying the write offset of this buffer.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#ab9ac2b8383541a245555a69097401cf3">More...</a><br /></td></tr>
<tr class="separator:ab9ac2b8383541a245555a69097401cf3 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a071d1d22a72209da193ad422dd3288b9 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a071d1d22a72209da193ad422dd3288b9">SetUnsignedByte</a> (long index, byte value)</td></tr>
<tr class="memdesc:a071d1d22a72209da193ad422dd3288b9 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="mdescLeft">&#160;</td><td class="mdescRight">Write the given unsigned byte value at the given location in the buffer backing store without modifying the write offset of this buffer.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a071d1d22a72209da193ad422dd3288b9">More...</a><br /></td></tr>
<tr class="separator:a071d1d22a72209da193ad422dd3288b9 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a0264e40335e1fd086302f5a11b7449cb inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a0264e40335e1fd086302f5a11b7449cb">SetBoolean</a> (long index, bool value)</td></tr>
<tr class="memdesc:a0264e40335e1fd086302f5a11b7449cb inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="mdescLeft">&#160;</td><td class="mdescRight">Write the given boolean value at the given location in the buffer backing store without modifying the write offset of this buffer.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a0264e40335e1fd086302f5a11b7449cb">More...</a><br /></td></tr>
<tr class="separator:a0264e40335e1fd086302f5a11b7449cb inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a5dfe2d0d6cc27a1ebae3514853f2e524 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a5dfe2d0d6cc27a1ebae3514853f2e524">SetChar</a> (long index, char value)</td></tr>
<tr class="memdesc:a5dfe2d0d6cc27a1ebae3514853f2e524 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="mdescLeft">&#160;</td><td class="mdescRight">Write the given 2 byte char value at the given location in the buffer backing store without modifying the write offset of this buffer.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a5dfe2d0d6cc27a1ebae3514853f2e524">More...</a><br /></td></tr>
<tr class="separator:a5dfe2d0d6cc27a1ebae3514853f2e524 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:abed9cd5b8e56cedca976b3e151536a69 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#abed9cd5b8e56cedca976b3e151536a69">SetShort</a> (long index, short value)</td></tr>
<tr class="memdesc:abed9cd5b8e56cedca976b3e151536a69 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="mdescLeft">&#160;</td><td class="mdescRight">Write the given 2 byte short value at the given location in the buffer backing store without modifying the write offset of this buffer.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#abed9cd5b8e56cedca976b3e151536a69">More...</a><br /></td></tr>
<tr class="separator:abed9cd5b8e56cedca976b3e151536a69 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:aafdf0f13c77ef405fd0e1608898eb0fd inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#aafdf0f13c77ef405fd0e1608898eb0fd">SetUnsignedShort</a> (long index, ushort value)</td></tr>
<tr class="memdesc:aafdf0f13c77ef405fd0e1608898eb0fd inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="mdescLeft">&#160;</td><td class="mdescRight">Write the given 2 byte unsigned short value at the given location in the buffer backing store without modifying the write offset of this buffer.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#aafdf0f13c77ef405fd0e1608898eb0fd">More...</a><br /></td></tr>
<tr class="separator:aafdf0f13c77ef405fd0e1608898eb0fd inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a27ac6d5b0a5322603d052eed769829eb inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a27ac6d5b0a5322603d052eed769829eb">SetInt</a> (long index, int value)</td></tr>
<tr class="memdesc:a27ac6d5b0a5322603d052eed769829eb inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="mdescLeft">&#160;</td><td class="mdescRight">Write the given 4 byte int value at the given location in the buffer backing store without modifying the write offset of this buffer.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a27ac6d5b0a5322603d052eed769829eb">More...</a><br /></td></tr>
<tr class="separator:a27ac6d5b0a5322603d052eed769829eb inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a9ef7bf65e6f953197d4ae9ce6fbcd3dc inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a9ef7bf65e6f953197d4ae9ce6fbcd3dc">SetUnsignedInt</a> (long index, uint value)</td></tr>
<tr class="memdesc:a9ef7bf65e6f953197d4ae9ce6fbcd3dc inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="mdescLeft">&#160;</td><td class="mdescRight">Write the given 4 byte unsigned int value at the given location in the buffer backing store without modifying the write offset of this buffer.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a9ef7bf65e6f953197d4ae9ce6fbcd3dc">More...</a><br /></td></tr>
<tr class="separator:a9ef7bf65e6f953197d4ae9ce6fbcd3dc inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:aca75d734fda017b5ebddc186d6de124b inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#aca75d734fda017b5ebddc186d6de124b">SetLong</a> (long index, long value)</td></tr>
<tr class="memdesc:aca75d734fda017b5ebddc186d6de124b inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="mdescLeft">&#160;</td><td class="mdescRight">Write the given 8 byte long value at the given location in the buffer backing store without modifying the write offset of this buffer.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#aca75d734fda017b5ebddc186d6de124b">More...</a><br /></td></tr>
<tr class="separator:aca75d734fda017b5ebddc186d6de124b inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a58fe0350c543162431f0ded36eff905a inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a58fe0350c543162431f0ded36eff905a">SetUnsignedLong</a> (long index, ulong value)</td></tr>
<tr class="memdesc:a58fe0350c543162431f0ded36eff905a inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="mdescLeft">&#160;</td><td class="mdescRight">Write the given 8 byte unsigned long value at the given location in the buffer backing store without modifying the write offset of this buffer.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a58fe0350c543162431f0ded36eff905a">More...</a><br /></td></tr>
<tr class="separator:a58fe0350c543162431f0ded36eff905a inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a3cf4e44bb7081862322580094cbdad22 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a3cf4e44bb7081862322580094cbdad22">SetFloat</a> (long index, float value)</td></tr>
<tr class="memdesc:a3cf4e44bb7081862322580094cbdad22 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="mdescLeft">&#160;</td><td class="mdescRight">Write the given 4 byte float value at the given location in the buffer backing store without modifying the write offset of this buffer.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a3cf4e44bb7081862322580094cbdad22">More...</a><br /></td></tr>
<tr class="separator:a3cf4e44bb7081862322580094cbdad22 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a3d21aef1d546242950038fa1ca6b9cd0 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a3d21aef1d546242950038fa1ca6b9cd0">SetDouble</a> (long index, double value)</td></tr>
<tr class="memdesc:a3d21aef1d546242950038fa1ca6b9cd0 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="mdescLeft">&#160;</td><td class="mdescRight">Write the given 8 byte double value at the given location in the buffer backing store without modifying the write offset of this buffer.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a3d21aef1d546242950038fa1ca6b9cd0">More...</a><br /></td></tr>
<tr class="separator:a3d21aef1d546242950038fa1ca6b9cd0 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:acbbc7feea154d9af93a37339a9676f94 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memItemLeft" align="right" valign="top">sbyte&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#acbbc7feea154d9af93a37339a9676f94">ReadByte</a> ()</td></tr>
<tr class="memdesc:acbbc7feea154d9af93a37339a9676f94 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="mdescLeft">&#160;</td><td class="mdescRight">Read a signed byte from the buffer and advance the read offset.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#acbbc7feea154d9af93a37339a9676f94">More...</a><br /></td></tr>
<tr class="separator:acbbc7feea154d9af93a37339a9676f94 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a7fd1e33d81fffca6534549f576e0a150 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memItemLeft" align="right" valign="top">byte&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a7fd1e33d81fffca6534549f576e0a150">ReadUnsignedByte</a> ()</td></tr>
<tr class="memdesc:a7fd1e33d81fffca6534549f576e0a150 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="mdescLeft">&#160;</td><td class="mdescRight">Read a unsigned byte from the buffer and advance the read offset.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a7fd1e33d81fffca6534549f576e0a150">More...</a><br /></td></tr>
<tr class="separator:a7fd1e33d81fffca6534549f576e0a150 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a7e369a78fd0e0de6b5b7564df69ac062 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memItemLeft" align="right" valign="top">bool&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a7e369a78fd0e0de6b5b7564df69ac062">ReadBoolean</a> ()</td></tr>
<tr class="memdesc:a7e369a78fd0e0de6b5b7564df69ac062 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="mdescLeft">&#160;</td><td class="mdescRight">Reads the next byte from the buffer and returns the boolean value.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a7e369a78fd0e0de6b5b7564df69ac062">More...</a><br /></td></tr>
<tr class="separator:a7e369a78fd0e0de6b5b7564df69ac062 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a66432aecd9e93c6b8495950c763aef58 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memItemLeft" align="right" valign="top">char&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a66432aecd9e93c6b8495950c763aef58">ReadChar</a> ()</td></tr>
<tr class="memdesc:a66432aecd9e93c6b8495950c763aef58 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="mdescLeft">&#160;</td><td class="mdescRight">Reads the two bytes from the buffer and returns the char value.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a66432aecd9e93c6b8495950c763aef58">More...</a><br /></td></tr>
<tr class="separator:a66432aecd9e93c6b8495950c763aef58 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a09d887d925043e090aa6c5622417ed7a inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memItemLeft" align="right" valign="top">short&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a09d887d925043e090aa6c5622417ed7a">ReadShort</a> ()</td></tr>
<tr class="memdesc:a09d887d925043e090aa6c5622417ed7a inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="mdescLeft">&#160;</td><td class="mdescRight">Reads the next two bytes from the buffer and returns the short value.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a09d887d925043e090aa6c5622417ed7a">More...</a><br /></td></tr>
<tr class="separator:a09d887d925043e090aa6c5622417ed7a inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a435944cb521dc3cdea4bd6825871abbb inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memItemLeft" align="right" valign="top">ushort&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a435944cb521dc3cdea4bd6825871abbb">ReadUnsignedShort</a> ()</td></tr>
<tr class="memdesc:a435944cb521dc3cdea4bd6825871abbb inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="mdescLeft">&#160;</td><td class="mdescRight">Reads the next two bytes from the buffer and returns the unsigned short value.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a435944cb521dc3cdea4bd6825871abbb">More...</a><br /></td></tr>
<tr class="separator:a435944cb521dc3cdea4bd6825871abbb inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:acfb078c7ac2546ca114a54ecfa6d774f inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#acfb078c7ac2546ca114a54ecfa6d774f">ReadInt</a> ()</td></tr>
<tr class="memdesc:acfb078c7ac2546ca114a54ecfa6d774f inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="mdescLeft">&#160;</td><td class="mdescRight">Reads the next four bytes from the buffer and returns the int value.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#acfb078c7ac2546ca114a54ecfa6d774f">More...</a><br /></td></tr>
<tr class="separator:acfb078c7ac2546ca114a54ecfa6d774f inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ac6ddb6631f833c14e2617db4b30de1f9 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memItemLeft" align="right" valign="top">uint&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#ac6ddb6631f833c14e2617db4b30de1f9">ReadUnsignedInt</a> ()</td></tr>
<tr class="memdesc:ac6ddb6631f833c14e2617db4b30de1f9 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="mdescLeft">&#160;</td><td class="mdescRight">Reads the next four bytes from the buffer and returns the unsigned int value.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#ac6ddb6631f833c14e2617db4b30de1f9">More...</a><br /></td></tr>
<tr class="separator:ac6ddb6631f833c14e2617db4b30de1f9 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a26a8a311b66c10c9e239f369a62c6032 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memItemLeft" align="right" valign="top">long&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a26a8a311b66c10c9e239f369a62c6032">ReadLong</a> ()</td></tr>
<tr class="memdesc:a26a8a311b66c10c9e239f369a62c6032 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="mdescLeft">&#160;</td><td class="mdescRight">Reads the next eight bytes from the buffer and returns the long value.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a26a8a311b66c10c9e239f369a62c6032">More...</a><br /></td></tr>
<tr class="separator:a26a8a311b66c10c9e239f369a62c6032 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a0e5edaacb12fb2e271d6a0bdd84865c8 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memItemLeft" align="right" valign="top">ulong&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a0e5edaacb12fb2e271d6a0bdd84865c8">ReadUnsignedLong</a> ()</td></tr>
<tr class="memdesc:a0e5edaacb12fb2e271d6a0bdd84865c8 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="mdescLeft">&#160;</td><td class="mdescRight">Reads the next eight bytes from the buffer and returns the unsigned long value.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a0e5edaacb12fb2e271d6a0bdd84865c8">More...</a><br /></td></tr>
<tr class="separator:a0e5edaacb12fb2e271d6a0bdd84865c8 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a5d3156d634994dabfde848accb647b4b inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memItemLeft" align="right" valign="top">float&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a5d3156d634994dabfde848accb647b4b">ReadFloat</a> ()</td></tr>
<tr class="memdesc:a5d3156d634994dabfde848accb647b4b inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="mdescLeft">&#160;</td><td class="mdescRight">Reads the next four bytes from the buffer and returns the float value.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a5d3156d634994dabfde848accb647b4b">More...</a><br /></td></tr>
<tr class="separator:a5d3156d634994dabfde848accb647b4b inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:aab45e9e0e1a2e9a2e79cfa134f0dbba0 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memItemLeft" align="right" valign="top">double&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#aab45e9e0e1a2e9a2e79cfa134f0dbba0">ReadDouble</a> ()</td></tr>
<tr class="memdesc:aab45e9e0e1a2e9a2e79cfa134f0dbba0 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="mdescLeft">&#160;</td><td class="mdescRight">Reads the next eight bytes from the buffer and returns the double value.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#aab45e9e0e1a2e9a2e79cfa134f0dbba0">More...</a><br /></td></tr>
<tr class="separator:aab45e9e0e1a2e9a2e79cfa134f0dbba0 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a6e5b361f9dfa2fd871e49fac59cb3e0a inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a6e5b361f9dfa2fd871e49fac59cb3e0a">WriteByte</a> (sbyte value)</td></tr>
<tr class="memdesc:a6e5b361f9dfa2fd871e49fac59cb3e0a inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="mdescLeft">&#160;</td><td class="mdescRight">Writes the given byte value into this buffer and increases the write offset.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a6e5b361f9dfa2fd871e49fac59cb3e0a">More...</a><br /></td></tr>
<tr class="separator:a6e5b361f9dfa2fd871e49fac59cb3e0a inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a9ef10c994eb0d7b9171a9489a18cfdec inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a9ef10c994eb0d7b9171a9489a18cfdec">WriteUnsignedByte</a> (byte value)</td></tr>
<tr class="memdesc:a9ef10c994eb0d7b9171a9489a18cfdec inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="mdescLeft">&#160;</td><td class="mdescRight">Writes the given unsigned byte value into this buffer and increases the write offset.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a9ef10c994eb0d7b9171a9489a18cfdec">More...</a><br /></td></tr>
<tr class="separator:a9ef10c994eb0d7b9171a9489a18cfdec inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:af3098b7281ec6ab8ac69dc65ade1f207 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#af3098b7281ec6ab8ac69dc65ade1f207">WriteBoolean</a> (bool value)</td></tr>
<tr class="memdesc:af3098b7281ec6ab8ac69dc65ade1f207 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="mdescLeft">&#160;</td><td class="mdescRight">Writes the given boolean value into this buffer as a single byte and increases the write offset.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#af3098b7281ec6ab8ac69dc65ade1f207">More...</a><br /></td></tr>
<tr class="separator:af3098b7281ec6ab8ac69dc65ade1f207 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a47b46607343045f604e74a5fc8eb9f2e inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a47b46607343045f604e74a5fc8eb9f2e">WriteShort</a> (short value)</td></tr>
<tr class="memdesc:a47b46607343045f604e74a5fc8eb9f2e inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="mdescLeft">&#160;</td><td class="mdescRight">Writes the given two byte short value into this buffer and increases the write offset.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a47b46607343045f604e74a5fc8eb9f2e">More...</a><br /></td></tr>
<tr class="separator:a47b46607343045f604e74a5fc8eb9f2e inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a23efc406af67426c4bc40ba05dd47866 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a23efc406af67426c4bc40ba05dd47866">WriteUnsignedShort</a> (ushort value)</td></tr>
<tr class="memdesc:a23efc406af67426c4bc40ba05dd47866 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="mdescLeft">&#160;</td><td class="mdescRight">Writes the given two byte unsigned short value into this buffer and increases the write offset.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a23efc406af67426c4bc40ba05dd47866">More...</a><br /></td></tr>
<tr class="separator:a23efc406af67426c4bc40ba05dd47866 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a1f5b6f52076a07a76722dc009689d388 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a1f5b6f52076a07a76722dc009689d388">WriteInt</a> (int value)</td></tr>
<tr class="memdesc:a1f5b6f52076a07a76722dc009689d388 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="mdescLeft">&#160;</td><td class="mdescRight">Writes the given four byte int value into this buffer and increases the write offset.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a1f5b6f52076a07a76722dc009689d388">More...</a><br /></td></tr>
<tr class="separator:a1f5b6f52076a07a76722dc009689d388 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a482682e4697278cd89d1ab9278a50fd9 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a482682e4697278cd89d1ab9278a50fd9">WriteUnsignedInt</a> (uint value)</td></tr>
<tr class="memdesc:a482682e4697278cd89d1ab9278a50fd9 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="mdescLeft">&#160;</td><td class="mdescRight">Writes the given four byte unsigned int value into this buffer and increases the write offset.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a482682e4697278cd89d1ab9278a50fd9">More...</a><br /></td></tr>
<tr class="separator:a482682e4697278cd89d1ab9278a50fd9 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a440972781cc188e4c4298965e1c1f59b inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a440972781cc188e4c4298965e1c1f59b">WriteLong</a> (long value)</td></tr>
<tr class="memdesc:a440972781cc188e4c4298965e1c1f59b inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="mdescLeft">&#160;</td><td class="mdescRight">Writes the given eight byte long value into this buffer and increases the write offset.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a440972781cc188e4c4298965e1c1f59b">More...</a><br /></td></tr>
<tr class="separator:a440972781cc188e4c4298965e1c1f59b inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a6bb52912187f9a02f9ea31146d662487 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a6bb52912187f9a02f9ea31146d662487">WriteUnsignedLong</a> (ulong value)</td></tr>
<tr class="memdesc:a6bb52912187f9a02f9ea31146d662487 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="mdescLeft">&#160;</td><td class="mdescRight">Writes the given eight byte unsigned long value into this buffer and increases the write offset.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a6bb52912187f9a02f9ea31146d662487">More...</a><br /></td></tr>
<tr class="separator:a6bb52912187f9a02f9ea31146d662487 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a56282ad18642407f0bcc904601559629 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a56282ad18642407f0bcc904601559629">WriteFloat</a> (float value)</td></tr>
<tr class="memdesc:a56282ad18642407f0bcc904601559629 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="mdescLeft">&#160;</td><td class="mdescRight">Writes the given four byte float value into this buffer and increases the write offset.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a56282ad18642407f0bcc904601559629">More...</a><br /></td></tr>
<tr class="separator:a56282ad18642407f0bcc904601559629 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a2d784f8150ca88326e3a97ca9d3bea85 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a2d784f8150ca88326e3a97ca9d3bea85">WriteDouble</a> (double value)</td></tr>
<tr class="memdesc:a2d784f8150ca88326e3a97ca9d3bea85 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="mdescLeft">&#160;</td><td class="mdescRight">Writes the given eight byte double value into this buffer and increases the write offset.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#a2d784f8150ca88326e3a97ca9d3bea85">More...</a><br /></td></tr>
<tr class="separator:a2d784f8150ca88326e3a97ca9d3bea85 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memSeparator" colspan="2">&#160;</td></tr>
</table><table class="memberdecls">
<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="properties"></a>
Properties</h2></td></tr>
<tr class="memitem:ad66e20f0e5eda9dd91f5a95a44448c63"><td class="memItemLeft" align="right" valign="top">long&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#ad66e20f0e5eda9dd91f5a95a44448c63">Capacity</a><code> [get]</code></td></tr>
<tr class="memdesc:ad66e20f0e5eda9dd91f5a95a44448c63"><td class="mdescLeft">&#160;</td><td class="mdescRight">Gets the current capacity of this buffer instance which is the total amount of bytes that could be written before additional buffer capacity would be needed to allow more buffer writes. The remaining amount of writable bytes at any given time is the buffer capacity minus the write offset.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#ad66e20f0e5eda9dd91f5a95a44448c63">More...</a><br /></td></tr>
<tr class="separator:ad66e20f0e5eda9dd91f5a95a44448c63"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:afe9d5568cc763054acae3ef64c085378"><td class="memItemLeft" align="right" valign="top">bool&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#afe9d5568cc763054acae3ef64c085378">IsReadable</a><code> [get]</code></td></tr>
<tr class="memdesc:afe9d5568cc763054acae3ef64c085378"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns true if the current read offset is less than the current write offset meaning there are bytes available for reading.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#afe9d5568cc763054acae3ef64c085378">More...</a><br /></td></tr>
<tr class="separator:afe9d5568cc763054acae3ef64c085378"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ab24fa3dc40bde695f5780f029b71de15"><td class="memItemLeft" align="right" valign="top">long&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#ab24fa3dc40bde695f5780f029b71de15">ReadableBytes</a><code> [get]</code></td></tr>
<tr class="memdesc:ab24fa3dc40bde695f5780f029b71de15"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns the number of bytes that can currently be read from this buffer.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#ab24fa3dc40bde695f5780f029b71de15">More...</a><br /></td></tr>
<tr class="separator:ab24fa3dc40bde695f5780f029b71de15"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a48093d07b14ddf86f0ad2ef1d767f446"><td class="memItemLeft" align="right" valign="top">bool&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#a48093d07b14ddf86f0ad2ef1d767f446">IsWritable</a><code> [get]</code></td></tr>
<tr class="memdesc:a48093d07b14ddf86f0ad2ef1d767f446"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns true if write offset is less than the current buffer capacity limit.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#a48093d07b14ddf86f0ad2ef1d767f446">More...</a><br /></td></tr>
<tr class="separator:a48093d07b14ddf86f0ad2ef1d767f446"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ab870dbd9210b3290b97fd8eee5eb8a59"><td class="memItemLeft" align="right" valign="top">long&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#ab870dbd9210b3290b97fd8eee5eb8a59">WritableBytes</a><code> [get]</code></td></tr>
<tr class="memdesc:ab870dbd9210b3290b97fd8eee5eb8a59"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns the number of bytes that can currently be written from this buffer.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#ab870dbd9210b3290b97fd8eee5eb8a59">More...</a><br /></td></tr>
<tr class="separator:ab870dbd9210b3290b97fd8eee5eb8a59"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a071836b17919ceda9d202bf11686c727"><td class="memItemLeft" align="right" valign="top">long&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#a071836b17919ceda9d202bf11686c727">ReadOffset</a><code> [get, set]</code></td></tr>
<tr class="memdesc:a071836b17919ceda9d202bf11686c727"><td class="mdescLeft">&#160;</td><td class="mdescRight">Gets or sets the current read offset in this buffer. If the read offset is set to a value larger than the current write offset an exception is thrown.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#a071836b17919ceda9d202bf11686c727">More...</a><br /></td></tr>
<tr class="separator:a071836b17919ceda9d202bf11686c727"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a0f4baa8ae0d35ea54e39c25594e47ed5"><td class="memItemLeft" align="right" valign="top">long&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#a0f4baa8ae0d35ea54e39c25594e47ed5">WriteOffset</a><code> [get, set]</code></td></tr>
<tr class="memdesc:a0f4baa8ae0d35ea54e39c25594e47ed5"><td class="mdescLeft">&#160;</td><td class="mdescRight">Gets or sets the current write offset in this buffer. If the write offset is set to a value less than the current read offset or larger than the current buffer capacity an exception is thrown.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#a0f4baa8ae0d35ea54e39c25594e47ed5">More...</a><br /></td></tr>
<tr class="separator:a0f4baa8ae0d35ea54e39c25594e47ed5"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a5a6351dc69ca0d859e56f953a78e5455"><td class="memItemLeft" align="right" valign="top">uint&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#a5a6351dc69ca0d859e56f953a78e5455">ComponentCount</a><code> [get]</code></td></tr>
<tr class="memdesc:a5a6351dc69ca0d859e56f953a78e5455"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns the number of component buffers in this buffer. If this is not a composite buffer instance then the count will always be one. For a composite buffer this will be the count of the current number of component buffers contained within.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#a5a6351dc69ca0d859e56f953a78e5455">More...</a><br /></td></tr>
<tr class="separator:a5a6351dc69ca0d859e56f953a78e5455"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:afa8acee44b205fa61519603ec599addb"><td class="memItemLeft" align="right" valign="top">uint&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#afa8acee44b205fa61519603ec599addb">ReadableComponentCount</a><code> [get]</code></td></tr>
<tr class="memdesc:afa8acee44b205fa61519603ec599addb"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns the number of component buffers in this buffer that are readable and would be provided to calls to the for each readable buffer API. If this is not a composite buffer instance then the count will be at most one. For a composite buffer this will be the count of the current number of component buffers contained within that are readable.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#afa8acee44b205fa61519603ec599addb">More...</a><br /></td></tr>
<tr class="separator:afa8acee44b205fa61519603ec599addb"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:aac345932afa511777c950977562418c9"><td class="memItemLeft" align="right" valign="top">uint&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#aac345932afa511777c950977562418c9">WritableComponentCount</a><code> [get]</code></td></tr>
<tr class="memdesc:aac345932afa511777c950977562418c9"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns the number of component buffers in this buffer that are writable and would be provided to calls to the for each writable buffer API. If this is not a composite buffer instance then the count will be at most one. For a composite buffer this will be the count of the current number of component buffers contained within that are writable.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html#aac345932afa511777c950977562418c9">More...</a><br /></td></tr>
<tr class="separator:aac345932afa511777c950977562418c9"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="inherit_header properties_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td colspan="2" onclick="javascript:toggleInherit('properties_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors')"><img src="closed.png" alt="-"/>&#160;Properties inherited from <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html">Apache.Qpid.Proton.Buffer.IProtonBufferAccessors</a></td></tr>
<tr class="memitem:ad725007eec40b6a3d7f7faa2ca1c8df1 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memItemLeft" align="right" valign="top">byte&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#ad725007eec40b6a3d7f7faa2ca1c8df1">this[long i]</a><code> [get, set]</code></td></tr>
<tr class="memdesc:ad725007eec40b6a3d7f7faa2ca1c8df1 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="mdescLeft">&#160;</td><td class="mdescRight">Indexed access to single unsigned byte values within the buffer which does not modify the read or write index value. The given index must adhere to the same constraints as the get byte and set byte level APIs in this buffer class.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors.html#ad725007eec40b6a3d7f7faa2ca1c8df1">More...</a><br /></td></tr>
<tr class="separator:ad725007eec40b6a3d7f7faa2ca1c8df1 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBufferAccessors"><td class="memSeparator" colspan="2">&#160;</td></tr>
</table>
<h2 class="groupheader">Member Function Documentation</h2>
<a id="a9e9bca6e31529ac544ff1240e837680a"></a>
<h2 class="memtitle"><span class="permalink"><a href="#a9e9bca6e31529ac544ff1240e837680a">&#9670;&nbsp;</a></span>Compact()</h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a> Apache.Qpid.Proton.Buffer.IProtonBuffer.Compact </td>
          <td>(</td>
          <td class="paramname"></td><td>)</td>
          <td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Discards the read bytes, and moves the buffer contents to the beginning of the buffer. </p>
<dl class="section return"><dt>Returns</dt><dd>this buffer instance</dd></dl>

<p>Implemented in <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Buffer_1_1ProtonCompositeBuffer.html#ae6418a961aa5335c102ba48bb867c22a">Apache.Qpid.Proton.Buffer.ProtonCompositeBuffer</a>, and <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Buffer_1_1ProtonByteBuffer.html#a1ce2d129a3a8f70234ac3baee3e1b7fc">Apache.Qpid.Proton.Buffer.ProtonByteBuffer</a>.</p>

</div>
</div>
<a id="a4e34ec6f249c3188a3ca11cf965f1a1f"></a>
<h2 class="memtitle"><span class="permalink"><a href="#a4e34ec6f249c3188a3ca11cf965f1a1f">&#9670;&nbsp;</a></span>Copy() <span class="overload">[1/2]</span></h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a> Apache.Qpid.Proton.Buffer.IProtonBuffer.Copy </td>
          <td>(</td>
          <td class="paramname"></td><td>)</td>
          <td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Returns a copy of this buffer's readable bytes. Modifying the content of the returned buffer will not affect this buffers contents. The two buffers will maintain separate offsets. The returned copy has the write offset set to the length of the copy meaning that the entire copied region is read for reading. </p>
<dl class="section return"><dt>Returns</dt><dd>A new buffer with a copy of the readable bytes in this buffer</dd></dl>

<p>Implemented in <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Buffer_1_1ProtonCompositeBuffer.html#a0c3adebaa030e598287c7a3b35eef9bd">Apache.Qpid.Proton.Buffer.ProtonCompositeBuffer</a>, and <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Buffer_1_1ProtonByteBuffer.html#aeb648d1178b150897ae3df5fcba622d2">Apache.Qpid.Proton.Buffer.ProtonByteBuffer</a>.</p>

</div>
</div>
<a id="a2aacd63bf925e46bfb10991b4a5670dd"></a>
<h2 class="memtitle"><span class="permalink"><a href="#a2aacd63bf925e46bfb10991b4a5670dd">&#9670;&nbsp;</a></span>Copy() <span class="overload">[2/2]</span></h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a> Apache.Qpid.Proton.Buffer.IProtonBuffer.Copy </td>
          <td>(</td>
          <td class="paramtype">long&#160;</td>
          <td class="paramname"><em>index</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">long&#160;</td>
          <td class="paramname"><em>length</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Returns a copy of this buffer's readable bytes. Modifying the content of the returned buffer will not affect this buffers contents. The two buffers will maintain separate offsets. The amount and start of the data to be copied is provided by the index and length arguments. The returned copy has the write offset set to the length of the copy meaning that the entire copied region is read for reading. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">index</td><td>The read offset where the copy begins</td></tr>
    <tr><td class="paramname">length</td><td>The number of bytes to copy</td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>A new buffer with a copy of the readable bytes in the specified region</dd></dl>

<p>Implemented in <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Buffer_1_1ProtonCompositeBuffer.html#a8085c570a9e772f84c405e4c987bd9f3">Apache.Qpid.Proton.Buffer.ProtonCompositeBuffer</a>, and <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Buffer_1_1ProtonByteBuffer.html#ae4344c52b553c334bdeddadc9184a2db">Apache.Qpid.Proton.Buffer.ProtonByteBuffer</a>.</p>

</div>
</div>
<a id="a41a8a013dfa52854e15a197e60671d1d"></a>
<h2 class="memtitle"><span class="permalink"><a href="#a41a8a013dfa52854e15a197e60671d1d">&#9670;&nbsp;</a></span>CopyInto() <span class="overload">[1/2]</span></h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a> Apache.Qpid.Proton.Buffer.IProtonBuffer.CopyInto </td>
          <td>(</td>
          <td class="paramtype">long&#160;</td>
          <td class="paramname"><em>srcPos</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">byte[]&#160;</td>
          <td class="paramname"><em>dest</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">long&#160;</td>
          <td class="paramname"><em>destPos</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">long&#160;</td>
          <td class="paramname"><em>length</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Copies the given number of bytes from this buffer into the target byte buffer starting the read from the given position in this buffer and the write to at the given position in the destination buffer. The length parameter controls how many bytes are copied to the destination. This method does not modify the read or write offset values in this buffer. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">srcPos</td><td>Position in this buffer to begin the copy from</td></tr>
    <tr><td class="paramname">dest</td><td>Destination buffer where the copied bytes are written</td></tr>
    <tr><td class="paramname">destPos</td><td>Position in the destination where the write begins</td></tr>
    <tr><td class="paramname">length</td><td>Number of byte to copy to the destination</td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>This buffer instance.</dd></dl>
<dl class="exception"><dt>Exceptions</dt><dd>
  <table class="exception">
    <tr><td class="paramname">IndexOutOfRangeException</td><td></td></tr>
    <tr><td class="paramname">ArgumentOutOfRangeException</td><td></td></tr>
    <tr><td class="paramname">ArgumentNullException</td><td></td></tr>
  </table>
  </dd>
</dl>

<p>Implemented in <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Buffer_1_1ProtonCompositeBuffer.html#a1029317da4c71957ece036570ac826fe">Apache.Qpid.Proton.Buffer.ProtonCompositeBuffer</a>, and <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Buffer_1_1ProtonByteBuffer.html#a83a389b7d72771d5ab10fce435bbd5d8">Apache.Qpid.Proton.Buffer.ProtonByteBuffer</a>.</p>

</div>
</div>
<a id="a32c170ccd46b5fb32fbf88323932d50e"></a>
<h2 class="memtitle"><span class="permalink"><a href="#a32c170ccd46b5fb32fbf88323932d50e">&#9670;&nbsp;</a></span>CopyInto() <span class="overload">[2/2]</span></h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a> Apache.Qpid.Proton.Buffer.IProtonBuffer.CopyInto </td>
          <td>(</td>
          <td class="paramtype">long&#160;</td>
          <td class="paramname"><em>srcPos</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a>&#160;</td>
          <td class="paramname"><em>dest</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">long&#160;</td>
          <td class="paramname"><em>destPos</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">long&#160;</td>
          <td class="paramname"><em>length</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Copies the given number of bytes from this buffer into the target byte buffer starting the read from the given position in this buffer and the write to at the given position in the destination buffer. The length parameter controls how many bytes are copied to the destination. This method does not modify the read or write offset values in this buffer nor those of the destination buffer. The destination write index is an absolute index value unrelated to the write offset of the target. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">srcPos</td><td>Position in this buffer to begin the copy from</td></tr>
    <tr><td class="paramname">dest</td><td>Destination buffer where the copied bytes are written</td></tr>
    <tr><td class="paramname">destPos</td><td>Position in the destination where the write begins</td></tr>
    <tr><td class="paramname">length</td><td>Number of byte to copy to the destination</td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>This buffer instance.</dd></dl>
<dl class="exception"><dt>Exceptions</dt><dd>
  <table class="exception">
    <tr><td class="paramname">IndexOutOfRangeException</td><td></td></tr>
    <tr><td class="paramname">ArgumentOutOfRangeException</td><td></td></tr>
    <tr><td class="paramname">ArgumentNullException</td><td></td></tr>
  </table>
  </dd>
</dl>

<p>Implemented in <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Buffer_1_1ProtonCompositeBuffer.html#a394fddbd38b65b20ee841da29b338bc3">Apache.Qpid.Proton.Buffer.ProtonCompositeBuffer</a>, and <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Buffer_1_1ProtonByteBuffer.html#ae93a87e59b3d210408beb081dbb0d0b9">Apache.Qpid.Proton.Buffer.ProtonByteBuffer</a>.</p>

</div>
</div>
<a id="ab173585f0d8585926d4b516d9dc83568"></a>
<h2 class="memtitle"><span class="permalink"><a href="#ab173585f0d8585926d4b516d9dc83568">&#9670;&nbsp;</a></span>EnsureWritable()</h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a> Apache.Qpid.Proton.Buffer.IProtonBuffer.EnsureWritable </td>
          <td>(</td>
          <td class="paramtype">long&#160;</td>
          <td class="paramname"><em>amount</em></td><td>)</td>
          <td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Requests that the buffer ensure that there is enough allocated internal capacity such that the given number of bytes can be written without requiring additional allocations and that this amount does not exceed any total capacity restrictions for this buffer. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">amount</td><td>the number of bytes that should be available fro writing</td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>This buffer instance.</dd></dl>
<dl class="exception"><dt>Exceptions</dt><dd>
  <table class="exception">
    <tr><td class="paramname">ArgumentOutOfRangeException</td><td>If the requested amount exceeds capacity restrictions</td></tr>
  </table>
  </dd>
</dl>

<p>Implemented in <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Buffer_1_1ProtonCompositeBuffer.html#ab44d3208584325c28c1b96e3138d813a">Apache.Qpid.Proton.Buffer.ProtonCompositeBuffer</a>, and <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Buffer_1_1ProtonByteBuffer.html#af585e151af64dbbd27bc12392968b444">Apache.Qpid.Proton.Buffer.ProtonByteBuffer</a>.</p>

</div>
</div>
<a id="aa4919f89324410a3d598c3413ad4c3fd"></a>
<h2 class="memtitle"><span class="permalink"><a href="#aa4919f89324410a3d598c3413ad4c3fd">&#9670;&nbsp;</a></span>Fill()</h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a> Apache.Qpid.Proton.Buffer.IProtonBuffer.Fill </td>
          <td>(</td>
          <td class="paramtype">byte&#160;</td>
          <td class="paramname"><em>value</em></td><td>)</td>
          <td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Fill the buffer with the given byte value. This method does not respect the read offset nor the write offset but instead fills the entire backing buffer memory with the given value. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">value</td><td>The byte value to assign each byte in the backing store</td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>This buffer instance.</dd></dl>

<p>Implemented in <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Buffer_1_1ProtonCompositeBuffer.html#a893d1c476fb42c9bcbd38773fc59234d">Apache.Qpid.Proton.Buffer.ProtonCompositeBuffer</a>, and <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Buffer_1_1ProtonByteBuffer.html#ae6703a4dfd0feb26176b024bd783728b">Apache.Qpid.Proton.Buffer.ProtonByteBuffer</a>.</p>

</div>
</div>
<a id="a16128227e8ef3f6161f2d6b8f826140b"></a>
<h2 class="memtitle"><span class="permalink"><a href="#a16128227e8ef3f6161f2d6b8f826140b">&#9670;&nbsp;</a></span>ForEachReadableComponent()</h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">int Apache.Qpid.Proton.Buffer.IProtonBuffer.ForEachReadableComponent </td>
          <td>(</td>
          <td class="paramtype">in int&#160;</td>
          <td class="paramname"><em>index</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">in Func&lt; int, <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IReadableComponent.html">IReadableComponent</a>, bool &gt;&#160;</td>
          <td class="paramname"><em>processor</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Invokes the provided delegate for each readable component in this buffer and increments the provided index value for each invocation. The total number of buffers processed is returned to the caller. The delegate can stop processing at any time by returning false in which case this method will stop and return a negative value to indicate that processing stopped early and did not traverse all available components. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">index</td><td>a starting index which is increment after each call</td></tr>
    <tr><td class="paramname">processor</td><td>The delegate that will receive the components</td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>The number of components processed or negative if stopped early.</dd></dl>

<p>Implemented in <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Buffer_1_1ProtonCompositeBuffer.html#a31f253f35c41139e53868ef2d6ed98b2">Apache.Qpid.Proton.Buffer.ProtonCompositeBuffer</a>, and <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Buffer_1_1ProtonByteBuffer.html#a4b72990fd9cd1ac2fdb7df30649ff412">Apache.Qpid.Proton.Buffer.ProtonByteBuffer</a>.</p>

</div>
</div>
<a id="a01fc21814ec3dac24561c1a5713dba4f"></a>
<h2 class="memtitle"><span class="permalink"><a href="#a01fc21814ec3dac24561c1a5713dba4f">&#9670;&nbsp;</a></span>ForEachWritableComponent()</h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">int Apache.Qpid.Proton.Buffer.IProtonBuffer.ForEachWritableComponent </td>
          <td>(</td>
          <td class="paramtype">in int&#160;</td>
          <td class="paramname"><em>index</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">in Func&lt; int, <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IWritableComponent.html">IWritableComponent</a>, bool &gt;&#160;</td>
          <td class="paramname"><em>processor</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Invokes the provided delegate for each writable component in this buffer and increments the provided index value for each invocation. The total number of buffers processed is returned to the caller. The delegate can stop processing at any time by returning false in which case this method will stop and return a negative value to indicate that processing stopped early and did not traverse all available components. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">index</td><td>a starting index which is increment after each call</td></tr>
    <tr><td class="paramname">processor</td><td>The delegate that will receive the components</td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>The number of components processed or negative if stopped early.</dd></dl>

<p>Implemented in <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Buffer_1_1ProtonCompositeBuffer.html#aaa7c60a4af70f789bb56845ac759efc3">Apache.Qpid.Proton.Buffer.ProtonCompositeBuffer</a>, and <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Buffer_1_1ProtonByteBuffer.html#a0bb7a1bddaaf6cca84ca07f53e792816">Apache.Qpid.Proton.Buffer.ProtonByteBuffer</a>.</p>

</div>
</div>
<a id="aba3ce684d8bc18eff174454036aec4ef"></a>
<h2 class="memtitle"><span class="permalink"><a href="#aba3ce684d8bc18eff174454036aec4ef">&#9670;&nbsp;</a></span>ReadSplit()</h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a> Apache.Qpid.Proton.Buffer.IProtonBuffer.ReadSplit </td>
          <td>(</td>
          <td class="paramtype">long&#160;</td>
          <td class="paramname"><em>offset</em></td><td>)</td>
          <td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Splits the buffer into two distinct buffers at the given index plus the current read offset. The returned buffer will retain the read offset and write offset of this buffer but will be truncated to match the capacity provided by the split index, which implies that they might both be set to the capacity if they were previously set beyond the split index. The returned buffer will set its read and write offsets to zero if they fell prior to the given index otherwise they will be truncated to match the new buffer capacity. Split buffers support the standard buffer operations including resizing to ensure writable regions which implies that a buffer resize on either will cause them to no longer reference the same underlying memory region. If buffer implementations implement pooling then they must ensure proper release of shared buffer regions once both buffers no longer reference them. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">offset</td><td>The offset to split beyond the current read offset</td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>A new buffer that access the front portion of the buffer split</dd></dl>

<p>Implemented in <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Buffer_1_1ProtonCompositeBuffer.html#a1789d116827b9495b6a1def617eee3f0">Apache.Qpid.Proton.Buffer.ProtonCompositeBuffer</a>, and <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Buffer_1_1ProtonByteBuffer.html#a0777c671a3a2e609f776c878d636e692">Apache.Qpid.Proton.Buffer.ProtonByteBuffer</a>.</p>

</div>
</div>
<a id="a9260e7737c81b37f0c43f7d16bdba20f"></a>
<h2 class="memtitle"><span class="permalink"><a href="#a9260e7737c81b37f0c43f7d16bdba20f">&#9670;&nbsp;</a></span>Reclaim()</h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a> Apache.Qpid.Proton.Buffer.IProtonBuffer.Reclaim </td>
          <td>(</td>
          <td class="paramname"></td><td>)</td>
          <td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Reclaims read buffer space and returns it to the operating system or other pooling mechanisms if those are in place, then compacts the remaining buffer contents. For a non-composite buffer this operation could consist of allocating a smaller buffer to house any remaining unread bytes and freeing the larger backing buffer in some cases or it may result in a no-op depending on the buffer implementation. For the composite buffer case this operation provides an API which allows for fully read buffer constituents to be released and returned to a memory pool or back to the O/S. </p>
<dl class="section return"><dt>Returns</dt><dd>this buffer instance</dd></dl>

<p>Implemented in <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Buffer_1_1ProtonCompositeBuffer.html#ad960d0b45cd57be15947e483aacebeb7">Apache.Qpid.Proton.Buffer.ProtonCompositeBuffer</a>, and <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Buffer_1_1ProtonByteBuffer.html#a0fedd3d38837f8ee145db4eb9008a43f">Apache.Qpid.Proton.Buffer.ProtonByteBuffer</a>.</p>

</div>
</div>
<a id="a170b9b5f5e746734e498bf929a16549f"></a>
<h2 class="memtitle"><span class="permalink"><a href="#a170b9b5f5e746734e498bf929a16549f">&#9670;&nbsp;</a></span>Reset()</h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a> Apache.Qpid.Proton.Buffer.IProtonBuffer.Reset </td>
          <td>(</td>
          <td class="paramname"></td><td>)</td>
          <td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Resets the read and write offset values to zero. </p>
<dl class="section return"><dt>Returns</dt><dd>This buffer instance.</dd></dl>

<p>Implemented in <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Buffer_1_1ProtonCompositeBuffer.html#a25442aea04e52e38757be397279780e0">Apache.Qpid.Proton.Buffer.ProtonCompositeBuffer</a>, and <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Buffer_1_1ProtonByteBuffer.html#aca2e65e4110eae90c776bedad536937d">Apache.Qpid.Proton.Buffer.ProtonByteBuffer</a>.</p>

</div>
</div>
<a id="a48952f07b1d51891f76974b80c52df87"></a>
<h2 class="memtitle"><span class="permalink"><a href="#a48952f07b1d51891f76974b80c52df87">&#9670;&nbsp;</a></span>SkipBytes()</h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a> Apache.Qpid.Proton.Buffer.IProtonBuffer.SkipBytes </td>
          <td>(</td>
          <td class="paramtype">long&#160;</td>
          <td class="paramname"><em>amount</em></td><td>)</td>
          <td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Advance the buffer read offset by the specified amount effectively skipping that number of bytes from being read. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">amount</td><td>The number of bytes to skip</td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>this buffer instance</dd></dl>
<dl class="exception"><dt>Exceptions</dt><dd>
  <table class="exception">
    <tr><td class="paramname">IndexOutOfRangeException</td><td>If the amount is negative or larger than readable size</td></tr>
  </table>
  </dd>
</dl>

<p>Implemented in <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Buffer_1_1ProtonCompositeBuffer.html#a74831fa68a0d07e2b9bf875fced887b8">Apache.Qpid.Proton.Buffer.ProtonCompositeBuffer</a>, and <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Buffer_1_1ProtonByteBuffer.html#a4c79e2076cb29946d99862f0cc090aaf">Apache.Qpid.Proton.Buffer.ProtonByteBuffer</a>.</p>

</div>
</div>
<a id="acae3a5f39a75855252ad922ca9c2065c"></a>
<h2 class="memtitle"><span class="permalink"><a href="#acae3a5f39a75855252ad922ca9c2065c">&#9670;&nbsp;</a></span>Split() <span class="overload">[1/2]</span></h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a> Apache.Qpid.Proton.Buffer.IProtonBuffer.Split </td>
          <td>(</td>
          <td class="paramname"></td><td>)</td>
          <td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Splits the buffer into two buffers at the write offset. The resulting buffer will comprise the read and readable portions of this buffer with the write offset and capacity set to the current write offset. This buffer will lose access to the split region and its read offset will be set to the current write offset. This buffer will also have its capacity reduced by the number of bytes in the returned buffer (i.e. the current number of read and readable bytes). Split buffers support the standard buffer operations including resizing to ensure writable regions which implies that a buffer resize on either will cause them to no longer reference the same underlying memory region. If buffer implementations implement pooling then they must ensure proper release of shared buffer regions once both buffers no longer reference them. </p>
<dl class="section return"><dt>Returns</dt><dd>A new buffer that access the front portion of the buffer split</dd></dl>

<p>Implemented in <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Buffer_1_1ProtonCompositeBuffer.html#a4b3ce7c5921e8fff7873d2b2a40be566">Apache.Qpid.Proton.Buffer.ProtonCompositeBuffer</a>, and <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Buffer_1_1ProtonByteBuffer.html#a7e17b377b794582bd89c28f23050d244">Apache.Qpid.Proton.Buffer.ProtonByteBuffer</a>.</p>

</div>
</div>
<a id="a4326c640d62c909fdd6ed24202add322"></a>
<h2 class="memtitle"><span class="permalink"><a href="#a4326c640d62c909fdd6ed24202add322">&#9670;&nbsp;</a></span>Split() <span class="overload">[2/2]</span></h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a> Apache.Qpid.Proton.Buffer.IProtonBuffer.Split </td>
          <td>(</td>
          <td class="paramtype">long&#160;</td>
          <td class="paramname"><em>index</em></td><td>)</td>
          <td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Splits the buffer into two distinct buffers at the given index. The returned buffer will retain the read offset and write offset of this buffer but will be truncated to match the capacity provided by the split index, which implies that they might both be set to the capacity if they were previously set beyond the split index. The returned buffer will set its read and write offsets to zero if they fell prior to the given index otherwise they will be truncated to match the new buffer capacity. Split buffers support the standard buffer operations including resizing to ensure writable regions which implies that a buffer resize on either will cause them to no longer reference the same underlying memory region. If buffer implementations implement pooling then they must ensure proper release of shared buffer regions once both buffers no longer reference them. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">index</td><td>The index in this buffer where the split occurs</td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>A new buffer that access the front portion of the buffer split</dd></dl>

<p>Implemented in <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Buffer_1_1ProtonCompositeBuffer.html#aac68047141f77ada796a22c9cac9129e">Apache.Qpid.Proton.Buffer.ProtonCompositeBuffer</a>, and <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Buffer_1_1ProtonByteBuffer.html#a86a2fb56b8f514d3f344b15ba7cd8b35">Apache.Qpid.Proton.Buffer.ProtonByteBuffer</a>.</p>

</div>
</div>
<a id="a4a53e9991dea44bac8a13757025401f0"></a>
<h2 class="memtitle"><span class="permalink"><a href="#a4a53e9991dea44bac8a13757025401f0">&#9670;&nbsp;</a></span>ToString()</h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">string Apache.Qpid.Proton.Buffer.IProtonBuffer.ToString </td>
          <td>(</td>
          <td class="paramtype">Encoding&#160;</td>
          <td class="paramname"><em>encoding</em></td><td>)</td>
          <td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Coverts the readable bytes in this buffer into a string value using the Encoding value provided. The underlying read and write offset values are not modified as a result of this operation. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">encoding</td><td>The encoding to use to convert the readable bytes</td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>The string value of the readable bytes as converted by the provided Encoding</dd></dl>

<p>Implemented in <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Buffer_1_1ProtonCompositeBuffer.html#a1f042762990e12290a960086b7e341da">Apache.Qpid.Proton.Buffer.ProtonCompositeBuffer</a>, and <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Buffer_1_1ProtonByteBuffer.html#a9b1e80d1d6d918c9bf8a18483ac82b49">Apache.Qpid.Proton.Buffer.ProtonByteBuffer</a>.</p>

</div>
</div>
<a id="abbdc44cbc36ca9126dab0a8af935f9ce"></a>
<h2 class="memtitle"><span class="permalink"><a href="#abbdc44cbc36ca9126dab0a8af935f9ce">&#9670;&nbsp;</a></span>WriteBytes() <span class="overload">[1/3]</span></h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a> Apache.Qpid.Proton.Buffer.IProtonBuffer.WriteBytes </td>
          <td>(</td>
          <td class="paramtype">byte[]&#160;</td>
          <td class="paramname"><em>source</em></td><td>)</td>
          <td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Writes the contents of the given byte array into this buffer and advances the write offset by the number of bytes written. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">source</td><td>The byte buffer to be written into this buffer</td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>this buffer instance</dd></dl>
<dl class="exception"><dt>Exceptions</dt><dd>
  <table class="exception">
    <tr><td class="paramname">IndexOutOfRangeException</td><td>If there are not enough writable bytes</td></tr>
  </table>
  </dd>
</dl>

<p>Implemented in <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Buffer_1_1ProtonCompositeBuffer.html#a3d76b4d15453b19a3f62a023170d2e63">Apache.Qpid.Proton.Buffer.ProtonCompositeBuffer</a>, and <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Buffer_1_1ProtonByteBuffer.html#aabcc44ff17631451a9ea12881a2993b0">Apache.Qpid.Proton.Buffer.ProtonByteBuffer</a>.</p>

</div>
</div>
<a id="a67567a96165c61ac62ebfe824005aefd"></a>
<h2 class="memtitle"><span class="permalink"><a href="#a67567a96165c61ac62ebfe824005aefd">&#9670;&nbsp;</a></span>WriteBytes() <span class="overload">[2/3]</span></h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a> Apache.Qpid.Proton.Buffer.IProtonBuffer.WriteBytes </td>
          <td>(</td>
          <td class="paramtype">byte[]&#160;</td>
          <td class="paramname"><em>source</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">long&#160;</td>
          <td class="paramname"><em>offset</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">long&#160;</td>
          <td class="paramname"><em>length</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Writes the contents of the given byte array into this buffer and advances the write offset by the number of bytes written. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">source</td><td>The byte buffer to be written into this buffer</td></tr>
    <tr><td class="paramname">offset</td><td>The offset into the source buffer to start the write</td></tr>
    <tr><td class="paramname">length</td><td>The number of bytes from the source buffer to write into this buffer</td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>this buffer instance</dd></dl>
<dl class="exception"><dt>Exceptions</dt><dd>
  <table class="exception">
    <tr><td class="paramname">IndexOutOfRangeException</td><td>If there are not enough writable bytes</td></tr>
  </table>
  </dd>
</dl>

<p>Implemented in <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Buffer_1_1ProtonCompositeBuffer.html#aaa872c478c8a7e612315fee3eff6904b">Apache.Qpid.Proton.Buffer.ProtonCompositeBuffer</a>, and <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Buffer_1_1ProtonByteBuffer.html#a0c4209bf559eda9c806e156e053f18b7">Apache.Qpid.Proton.Buffer.ProtonByteBuffer</a>.</p>

</div>
</div>
<a id="aa0784e8f5a446e90b9ae57f16e3283ba"></a>
<h2 class="memtitle"><span class="permalink"><a href="#aa0784e8f5a446e90b9ae57f16e3283ba">&#9670;&nbsp;</a></span>WriteBytes() <span class="overload">[3/3]</span></h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a> Apache.Qpid.Proton.Buffer.IProtonBuffer.WriteBytes </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a>&#160;</td>
          <td class="paramname"><em>source</em></td><td>)</td>
          <td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Transfers the bytes from the source buffer to this buffer starting at the current write offset and continues until the source buffer becomes unreadable. The write index of this buffer is increased by the number of bytes read from the source. The method also increases the read offset of the source by the same amount as was written. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">source</td><td>The byte buffer to be written into this buffer</td></tr>
    <tr><td class="paramname">length</td><td>The number of bytes to write into this buffer</td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>this buffer instance</dd></dl>
<dl class="exception"><dt>Exceptions</dt><dd>
  <table class="exception">
    <tr><td class="paramname">IndexOutOfRangeException</td><td>If there are not enough writable bytes</td></tr>
  </table>
  </dd>
</dl>

<p>Implemented in <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Buffer_1_1ProtonCompositeBuffer.html#a9c5123ff869f78b4bcc76562e97b8f04">Apache.Qpid.Proton.Buffer.ProtonCompositeBuffer</a>, and <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Buffer_1_1ProtonByteBuffer.html#a49e2b4738009ba86f7760e05cdc0639d">Apache.Qpid.Proton.Buffer.ProtonByteBuffer</a>.</p>

</div>
</div>
<a id="a5de1edd80e6b1d0ebc7b18845ecfc8b1"></a>
<h2 class="memtitle"><span class="permalink"><a href="#a5de1edd80e6b1d0ebc7b18845ecfc8b1">&#9670;&nbsp;</a></span>WriteSplit()</h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a> Apache.Qpid.Proton.Buffer.IProtonBuffer.WriteSplit </td>
          <td>(</td>
          <td class="paramtype">long&#160;</td>
          <td class="paramname"><em>offset</em></td><td>)</td>
          <td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Splits the buffer into two distinct buffers at the given index plus the current write offset. The returned buffer will retain the read offset and write offset of this buffer but will be truncated to match the capacity provided by the split index, which implies that they might both be set to the capacity if they were previously set to the split index. The returned buffer will set its read and write offsets to zero if they fell prior to the given index otherwise they will be truncated to match the new buffer capacity. Split buffers support the standard buffer operations including resizing to ensure writable regions which implies that a buffer resize on either will cause them to no longer reference the same underlying memory region. If buffer implementations implement pooling then they must ensure proper release of shared buffer regions once both buffers no longer reference them. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">offset</td><td>The offset to split beyond the current write offset</td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>A new buffer that access the front portion of the buffer split</dd></dl>

<p>Implemented in <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Buffer_1_1ProtonCompositeBuffer.html#acc08a8be572c0e7cbb262ac288e5f169">Apache.Qpid.Proton.Buffer.ProtonCompositeBuffer</a>, and <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Buffer_1_1ProtonByteBuffer.html#a30f81737b7f69d70ea245c4891d02cb6">Apache.Qpid.Proton.Buffer.ProtonByteBuffer</a>.</p>

</div>
</div>
<h2 class="groupheader">Property Documentation</h2>
<a id="ad66e20f0e5eda9dd91f5a95a44448c63"></a>
<h2 class="memtitle"><span class="permalink"><a href="#ad66e20f0e5eda9dd91f5a95a44448c63">&#9670;&nbsp;</a></span>Capacity</h2>

<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">long Apache.Qpid.Proton.Buffer.IProtonBuffer.Capacity</td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">get</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Gets the current capacity of this buffer instance which is the total amount of bytes that could be written before additional buffer capacity would be needed to allow more buffer writes. The remaining amount of writable bytes at any given time is the buffer capacity minus the write offset. </p>

</div>
</div>
<a id="a5a6351dc69ca0d859e56f953a78e5455"></a>
<h2 class="memtitle"><span class="permalink"><a href="#a5a6351dc69ca0d859e56f953a78e5455">&#9670;&nbsp;</a></span>ComponentCount</h2>

<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">uint Apache.Qpid.Proton.Buffer.IProtonBuffer.ComponentCount</td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">get</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Returns the number of component buffers in this buffer. If this is not a composite buffer instance then the count will always be one. For a composite buffer this will be the count of the current number of component buffers contained within. </p>

</div>
</div>
<a id="afe9d5568cc763054acae3ef64c085378"></a>
<h2 class="memtitle"><span class="permalink"><a href="#afe9d5568cc763054acae3ef64c085378">&#9670;&nbsp;</a></span>IsReadable</h2>

<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">bool Apache.Qpid.Proton.Buffer.IProtonBuffer.IsReadable</td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">get</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Returns true if the current read offset is less than the current write offset meaning there are bytes available for reading. </p>

</div>
</div>
<a id="a48093d07b14ddf86f0ad2ef1d767f446"></a>
<h2 class="memtitle"><span class="permalink"><a href="#a48093d07b14ddf86f0ad2ef1d767f446">&#9670;&nbsp;</a></span>IsWritable</h2>

<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">bool Apache.Qpid.Proton.Buffer.IProtonBuffer.IsWritable</td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">get</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Returns true if write offset is less than the current buffer capacity limit. </p>

</div>
</div>
<a id="ab24fa3dc40bde695f5780f029b71de15"></a>
<h2 class="memtitle"><span class="permalink"><a href="#ab24fa3dc40bde695f5780f029b71de15">&#9670;&nbsp;</a></span>ReadableBytes</h2>

<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">long Apache.Qpid.Proton.Buffer.IProtonBuffer.ReadableBytes</td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">get</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Returns the number of bytes that can currently be read from this buffer. </p>

</div>
</div>
<a id="afa8acee44b205fa61519603ec599addb"></a>
<h2 class="memtitle"><span class="permalink"><a href="#afa8acee44b205fa61519603ec599addb">&#9670;&nbsp;</a></span>ReadableComponentCount</h2>

<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">uint Apache.Qpid.Proton.Buffer.IProtonBuffer.ReadableComponentCount</td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">get</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Returns the number of component buffers in this buffer that are readable and would be provided to calls to the for each readable buffer API. If this is not a composite buffer instance then the count will be at most one. For a composite buffer this will be the count of the current number of component buffers contained within that are readable. </p>

</div>
</div>
<a id="a071836b17919ceda9d202bf11686c727"></a>
<h2 class="memtitle"><span class="permalink"><a href="#a071836b17919ceda9d202bf11686c727">&#9670;&nbsp;</a></span>ReadOffset</h2>

<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">long Apache.Qpid.Proton.Buffer.IProtonBuffer.ReadOffset</td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">get</span><span class="mlabel">set</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Gets or sets the current read offset in this buffer. If the read offset is set to a value larger than the current write offset an exception is thrown. </p>

</div>
</div>
<a id="ab870dbd9210b3290b97fd8eee5eb8a59"></a>
<h2 class="memtitle"><span class="permalink"><a href="#ab870dbd9210b3290b97fd8eee5eb8a59">&#9670;&nbsp;</a></span>WritableBytes</h2>

<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">long Apache.Qpid.Proton.Buffer.IProtonBuffer.WritableBytes</td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">get</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Returns the number of bytes that can currently be written from this buffer. </p>

</div>
</div>
<a id="aac345932afa511777c950977562418c9"></a>
<h2 class="memtitle"><span class="permalink"><a href="#aac345932afa511777c950977562418c9">&#9670;&nbsp;</a></span>WritableComponentCount</h2>

<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">uint Apache.Qpid.Proton.Buffer.IProtonBuffer.WritableComponentCount</td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">get</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Returns the number of component buffers in this buffer that are writable and would be provided to calls to the for each writable buffer API. If this is not a composite buffer instance then the count will be at most one. For a composite buffer this will be the count of the current number of component buffers contained within that are writable. </p>

</div>
</div>
<a id="a0f4baa8ae0d35ea54e39c25594e47ed5"></a>
<h2 class="memtitle"><span class="permalink"><a href="#a0f4baa8ae0d35ea54e39c25594e47ed5">&#9670;&nbsp;</a></span>WriteOffset</h2>

<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">long Apache.Qpid.Proton.Buffer.IProtonBuffer.WriteOffset</td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">get</span><span class="mlabel">set</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Gets or sets the current write offset in this buffer. If the write offset is set to a value less than the current read offset or larger than the current buffer capacity an exception is thrown. </p>

</div>
</div>
<hr/>The documentation for this interface was generated from the following file:<ul>
<li>src/Proton/Buffer/IProtonBuffer.cs</li>
</ul>
</div><!-- contents -->
<!-- start footer part -->
<hr class="footer"/><address class="footer"><small>
Generated by&#160;<a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
</small></address>
</body>
</html>
