<!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.Codec.Decoders.AbstractDescribedTypeDecoder Class 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_1Codec.html">Codec</a></li><li class="navelem"><a class="el" href="namespaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders.html">Decoders</a></li><li class="navelem"><a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1AbstractDescribedTypeDecoder.html">AbstractDescribedTypeDecoder</a></li>  </ul>
</div>
</div><!-- top -->
<div class="header">
  <div class="summary">
<a href="#pub-methods">Public Member Functions</a> &#124;
<a href="#pro-static-methods">Static Protected Member Functions</a> &#124;
<a href="#properties">Properties</a> &#124;
<a href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1AbstractDescribedTypeDecoder-members.html">List of all members</a>  </div>
  <div class="headertitle">
<div class="title">Apache.Qpid.Proton.Codec.Decoders.AbstractDescribedTypeDecoder Class Reference<span class="mlabels"><span class="mlabel">abstract</span></span></div>  </div>
</div><!--header-->
<div class="contents">
<div class="dynheader">
Inheritance diagram for Apache.Qpid.Proton.Codec.Decoders.AbstractDescribedTypeDecoder:</div>
<div class="dyncontent">
 <div class="center">
  <img src="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1AbstractDescribedTypeDecoder.png" usemap="#Apache.Qpid.Proton.Codec.Decoders.AbstractDescribedTypeDecoder_map" alt=""/>
  <map id="Apache.Qpid.Proton.Codec.Decoders.AbstractDescribedTypeDecoder_map" name="Apache.Qpid.Proton.Codec.Decoders.AbstractDescribedTypeDecoder_map">
<area href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IDescribedTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.IDescribedTypeDecoder" shape="rect" coords="0,56,544,80"/>
<area href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IStreamDescribedTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.IStreamDescribedTypeDecoder" shape="rect" coords="554,56,1098,80"/>
<area href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1ITypeDecoder.html" title="Defines an interface for an decoder of a specific type." alt="Apache.Qpid.Proton.Codec.ITypeDecoder" shape="rect" coords="0,0,544,24"/>
<area href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IStreamTypeDecoder.html" title="Defines an interface for an decoder of a specific type." alt="Apache.Qpid.Proton.Codec.IStreamTypeDecoder" shape="rect" coords="554,0,1098,24"/>
<area href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1AcceptedTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.Decoders.Messaging.AcceptedTypeDecoder" shape="rect" coords="831,168,1375,192"/>
<area href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1AmqpSequenceTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.Decoders.Messaging.AmqpSequenceTypeDecoder" shape="rect" coords="831,224,1375,248"/>
<area href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1AmqpValueTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.Decoders.Messaging.AmqpValueTypeDecoder" shape="rect" coords="831,280,1375,304"/>
<area href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1ApplicationPropertiesTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.Decoders.Messaging.ApplicationPropertiesTypeDecoder" shape="rect" coords="831,336,1375,360"/>
<area href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1DataTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.Decoders.Messaging.DataTypeDecoder" shape="rect" coords="831,392,1375,416"/>
<area href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1DeleteOnCloseTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.Decoders.Messaging.DeleteOnCloseTypeDecoder" shape="rect" coords="831,448,1375,472"/>
<area href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1DeleteOnNoLinksOrMessagesTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.Decoders.Messaging.DeleteOnNoLinksOrMessagesTypeDecoder" shape="rect" coords="831,504,1375,528"/>
<area href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1DeleteOnNoLinksTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.Decoders.Messaging.DeleteOnNoLinksTypeDecoder" shape="rect" coords="831,560,1375,584"/>
<area href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1DeleteOnNoMessagesTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.Decoders.Messaging.DeleteOnNoMessagesTypeDecoder" shape="rect" coords="831,616,1375,640"/>
<area href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1DeliveryAnnotationsTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.Decoders.Messaging.DeliveryAnnotationsTypeDecoder" shape="rect" coords="831,672,1375,696"/>
<area href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1FooterTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.Decoders.Messaging.FooterTypeDecoder" shape="rect" coords="831,728,1375,752"/>
<area href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1HeaderTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.Decoders.Messaging.HeaderTypeDecoder" shape="rect" coords="831,784,1375,808"/>
<area href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1MessageAnnotationsTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.Decoders.Messaging.MessageAnnotationsTypeDecoder" shape="rect" coords="831,840,1375,864"/>
<area href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1ModifiedTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.Decoders.Messaging.ModifiedTypeDecoder" shape="rect" coords="831,896,1375,920"/>
<area href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1PropertiesTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.Decoders.Messaging.PropertiesTypeDecoder" shape="rect" coords="831,952,1375,976"/>
<area href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1ReceivedTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.Decoders.Messaging.ReceivedTypeDecoder" shape="rect" coords="831,1008,1375,1032"/>
<area href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1RejectedTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.Decoders.Messaging.RejectedTypeDecoder" shape="rect" coords="831,1064,1375,1088"/>
<area href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1ReleasedTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.Decoders.Messaging.ReleasedTypeDecoder" shape="rect" coords="831,1120,1375,1144"/>
<area href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1SourceTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.Decoders.Messaging.SourceTypeDecoder" shape="rect" coords="831,1176,1375,1200"/>
<area href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1TargetTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.Decoders.Messaging.TargetTypeDecoder" shape="rect" coords="831,1232,1375,1256"/>
<area href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Security_1_1SaslChallengeTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.Decoders.Security.SaslChallengeTypeDecoder" shape="rect" coords="831,1288,1375,1312"/>
<area href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Security_1_1SaslInitTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.Decoders.Security.SaslInitTypeDecoder" shape="rect" coords="831,1344,1375,1368"/>
<area href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Security_1_1SaslMechanismsTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.Decoders.Security.SaslMechanismsTypeDecoder" shape="rect" coords="831,1400,1375,1424"/>
<area href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Security_1_1SaslOutcomeTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.Decoders.Security.SaslOutcomeTypeDecoder" shape="rect" coords="831,1456,1375,1480"/>
<area href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Security_1_1SaslResponseTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.Decoders.Security.SaslResponseTypeDecoder" shape="rect" coords="831,1512,1375,1536"/>
<area href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transactions_1_1CoordinatorTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.Decoders.Transactions.CoordinatorTypeDecoder" shape="rect" coords="831,1568,1375,1592"/>
<area href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transactions_1_1DeclareTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.Decoders.Transactions.DeclareTypeDecoder" shape="rect" coords="831,1624,1375,1648"/>
<area href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transactions_1_1DeclaredTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.Decoders.Transactions.DeclaredTypeDecoder" shape="rect" coords="831,1680,1375,1704"/>
<area href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transactions_1_1DischargeTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.Decoders.Transactions.DischargeTypeDecoder" shape="rect" coords="831,1736,1375,1760"/>
<area href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transactions_1_1TransactionalStateTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.Decoders.Transactions.TransactionalStateTypeDecoder" shape="rect" coords="831,1792,1375,1816"/>
<area href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1AttachTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.Decoders.Transport.AttachTypeDecoder" shape="rect" coords="831,1848,1375,1872"/>
<area href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1BeginTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.Decoders.Transport.BeginTypeDecoder" shape="rect" coords="831,1904,1375,1928"/>
<area href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1CloseTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.Decoders.Transport.CloseTypeDecoder" shape="rect" coords="831,1960,1375,1984"/>
<area href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1DetachTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.Decoders.Transport.DetachTypeDecoder" shape="rect" coords="831,2016,1375,2040"/>
<area href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1DispositionTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.Decoders.Transport.DispositionTypeDecoder" shape="rect" coords="831,2072,1375,2096"/>
<area href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1EndTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.Decoders.Transport.EndTypeDecoder" shape="rect" coords="831,2128,1375,2152"/>
<area href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1ErrorConditionTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.Decoders.Transport.ErrorConditionTypeDecoder" shape="rect" coords="831,2184,1375,2208"/>
<area href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1FlowTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.Decoders.Transport.FlowTypeDecoder" shape="rect" coords="831,2240,1375,2264"/>
<area href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1OpenTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.Decoders.Transport.OpenTypeDecoder" shape="rect" coords="831,2296,1375,2320"/>
<area href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1TransferTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.Decoders.Transport.TransferTypeDecoder" shape="rect" coords="831,2352,1375,2376"/>
<area href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1UnknownDescribedTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.Decoders.UnknownDescribedTypeDecoder" shape="rect" coords="831,2408,1375,2432"/>
  </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:ae061aa7e7f5a77704427df3f5f3b0ced"><td class="memItemLeft" align="right" valign="top">abstract object&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1AbstractDescribedTypeDecoder.html#ae061aa7e7f5a77704427df3f5f3b0ced">ReadValue</a> (<a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a> buffer, <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IDecoderState.html">IDecoderState</a> state)</td></tr>
<tr class="memdesc:ae061aa7e7f5a77704427df3f5f3b0ced"><td class="mdescLeft">&#160;</td><td class="mdescRight">Reads this decoders managed type from the given buffer and returns it.  <a href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1AbstractDescribedTypeDecoder.html#ae061aa7e7f5a77704427df3f5f3b0ced">More...</a><br /></td></tr>
<tr class="separator:ae061aa7e7f5a77704427df3f5f3b0ced"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a078588562887751293d3da82f98d340d"><td class="memItemLeft" align="right" valign="top">abstract Array&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1AbstractDescribedTypeDecoder.html#a078588562887751293d3da82f98d340d">ReadArrayElements</a> (<a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a> buffer, <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IDecoderState.html">IDecoderState</a> state, int count)</td></tr>
<tr class="memdesc:a078588562887751293d3da82f98d340d"><td class="mdescLeft">&#160;</td><td class="mdescRight">Reads a series of this type that have been encoded into the body of an Array type. When encoded into an array the values are encoded in series following the identifier for the type, this method is given a count of the number of instances that are encoded and should read each in succession and returning them in a new array.  <a href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1AbstractDescribedTypeDecoder.html#a078588562887751293d3da82f98d340d">More...</a><br /></td></tr>
<tr class="separator:a078588562887751293d3da82f98d340d"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a9f4e9646f8bfc875211d08d22b9deb83"><td class="memItemLeft" align="right" valign="top">abstract void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1AbstractDescribedTypeDecoder.html#a9f4e9646f8bfc875211d08d22b9deb83">SkipValue</a> (<a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a> buffer, <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IDecoderState.html">IDecoderState</a> state)</td></tr>
<tr class="memdesc:a9f4e9646f8bfc875211d08d22b9deb83"><td class="mdescLeft">&#160;</td><td class="mdescRight">Skips the value that this decoder is handling by skipping the encoded bytes in the provided buffer instance.  <a href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1AbstractDescribedTypeDecoder.html#a9f4e9646f8bfc875211d08d22b9deb83">More...</a><br /></td></tr>
<tr class="separator:a9f4e9646f8bfc875211d08d22b9deb83"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ad8120a79157b5c227aece3cdd07ccfe3"><td class="memItemLeft" align="right" valign="top">abstract object&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1AbstractDescribedTypeDecoder.html#ad8120a79157b5c227aece3cdd07ccfe3">ReadValue</a> (Stream stream, <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IStreamDecoderState.html">IStreamDecoderState</a> state)</td></tr>
<tr class="memdesc:ad8120a79157b5c227aece3cdd07ccfe3"><td class="mdescLeft">&#160;</td><td class="mdescRight">Reads this decoders managed type from the given buffer and returns it.  <a href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1AbstractDescribedTypeDecoder.html#ad8120a79157b5c227aece3cdd07ccfe3">More...</a><br /></td></tr>
<tr class="separator:ad8120a79157b5c227aece3cdd07ccfe3"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a968f5195461f8f89b30f7b27f5b041f2"><td class="memItemLeft" align="right" valign="top">abstract Array&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1AbstractDescribedTypeDecoder.html#a968f5195461f8f89b30f7b27f5b041f2">ReadArrayElements</a> (Stream stream, <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IStreamDecoderState.html">IStreamDecoderState</a> state, int count)</td></tr>
<tr class="memdesc:a968f5195461f8f89b30f7b27f5b041f2"><td class="mdescLeft">&#160;</td><td class="mdescRight">Reads a series of this type that have been encoded into the body of an Array type. When encoded into an array the values are encoded in series following the identifier for the type, this method is given a count of the number of instances that are encoded and should read each in succession and returning them in a new array.  <a href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1AbstractDescribedTypeDecoder.html#a968f5195461f8f89b30f7b27f5b041f2">More...</a><br /></td></tr>
<tr class="separator:a968f5195461f8f89b30f7b27f5b041f2"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a62838283f58a5298bbabd55f710759b0"><td class="memItemLeft" align="right" valign="top">abstract void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1AbstractDescribedTypeDecoder.html#a62838283f58a5298bbabd55f710759b0">SkipValue</a> (Stream stream, <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IStreamDecoderState.html">IStreamDecoderState</a> state)</td></tr>
<tr class="memdesc:a62838283f58a5298bbabd55f710759b0"><td class="mdescLeft">&#160;</td><td class="mdescRight">Skips the value that this decoder is handling by skipping the encoded bytes in the provided buffer instance.  <a href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1AbstractDescribedTypeDecoder.html#a62838283f58a5298bbabd55f710759b0">More...</a><br /></td></tr>
<tr class="separator:a62838283f58a5298bbabd55f710759b0"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:aa4ff9ddd7e55f3ca3ba8e176d210074d"><td class="memItemLeft" align="right" valign="top"><a id="aa4ff9ddd7e55f3ca3ba8e176d210074d"></a>
override string&#160;</td><td class="memItemRight" valign="bottom"><b>ToString</b> ()</td></tr>
<tr class="separator:aa4ff9ddd7e55f3ca3ba8e176d210074d"><td class="memSeparator" colspan="2">&#160;</td></tr>
</table><table class="memberdecls">
<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pro-static-methods"></a>
Static Protected Member Functions</h2></td></tr>
<tr class="memitem:aeb57a23a0f42ecf96c79ae87f96f49a2"><td class="memItemLeft" align="right" valign="top"><a id="aeb57a23a0f42ecf96c79ae87f96f49a2"></a>
static T&#160;</td><td class="memItemRight" valign="bottom"><b>CheckIsExpectedTypeAndCast&lt; T &gt;</b> (<a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1ITypeDecoder.html">ITypeDecoder</a> actual)</td></tr>
<tr class="separator:aeb57a23a0f42ecf96c79ae87f96f49a2"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a69920f75eb0e9aec16695c61149a9712"><td class="memItemLeft" align="right" valign="top"><a id="a69920f75eb0e9aec16695c61149a9712"></a>
static T&#160;</td><td class="memItemRight" valign="bottom"><b>CheckIsExpectedTypeAndCast&lt; T &gt;</b> (<a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IStreamTypeDecoder.html">IStreamTypeDecoder</a> actual)</td></tr>
<tr class="separator:a69920f75eb0e9aec16695c61149a9712"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a75c9fc53584871d434628667f3781b09"><td class="memItemLeft" align="right" valign="top"><a id="a75c9fc53584871d434628667f3781b09"></a>
static void&#160;</td><td class="memItemRight" valign="bottom"><b>CheckIsExpectedType&lt; T &gt;</b> (<a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1ITypeDecoder.html">ITypeDecoder</a> actual)</td></tr>
<tr class="separator:a75c9fc53584871d434628667f3781b09"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a79bb70857c89cbd018bae5024cbbb007"><td class="memItemLeft" align="right" valign="top"><a id="a79bb70857c89cbd018bae5024cbbb007"></a>
static void&#160;</td><td class="memItemRight" valign="bottom"><b>CheckIsExpectedType&lt; T &gt;</b> (<a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IStreamTypeDecoder.html">IStreamTypeDecoder</a> actual)</td></tr>
<tr class="separator:a79bb70857c89cbd018bae5024cbbb007"><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:abc36e6d5bab64cba72d4c9344986d2e3"><td class="memItemLeft" align="right" valign="top"><a id="abc36e6d5bab64cba72d4c9344986d2e3"></a>
bool&#160;</td><td class="memItemRight" valign="bottom"><b>IsArrayType</b><code> [get]</code></td></tr>
<tr class="separator:abc36e6d5bab64cba72d4c9344986d2e3"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a4760a4479c5028c1b7ddc42f6162b55f"><td class="memItemLeft" align="right" valign="top"><a id="a4760a4479c5028c1b7ddc42f6162b55f"></a>
abstract <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Types_1_1Symbol.html">Symbol</a>&#160;</td><td class="memItemRight" valign="bottom"><b>DescriptorSymbol</b><code> [get]</code></td></tr>
<tr class="separator:a4760a4479c5028c1b7ddc42f6162b55f"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ae5ef600bea5b905996667aeeb3f254d4"><td class="memItemLeft" align="right" valign="top"><a id="ae5ef600bea5b905996667aeeb3f254d4"></a>
abstract ulong&#160;</td><td class="memItemRight" valign="bottom"><b>DescriptorCode</b><code> [get]</code></td></tr>
<tr class="separator:ae5ef600bea5b905996667aeeb3f254d4"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a8e639935d5259937c5049ac2c346fba7"><td class="memItemLeft" align="right" valign="top"><a id="a8e639935d5259937c5049ac2c346fba7"></a>
abstract Type&#160;</td><td class="memItemRight" valign="bottom"><b>DecodesType</b><code> [get]</code></td></tr>
<tr class="separator:a8e639935d5259937c5049ac2c346fba7"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="inherit_header properties_interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IDescribedTypeDecoder"><td colspan="2" onclick="javascript:toggleInherit('properties_interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IDescribedTypeDecoder')"><img src="closed.png" alt="-"/>&#160;Properties inherited from <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IDescribedTypeDecoder.html">Apache.Qpid.Proton.Codec.IDescribedTypeDecoder</a></td></tr>
<tr class="memitem:acdf75682b5a1a1b96f19ec1121eb3abd inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IDescribedTypeDecoder"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Types_1_1Symbol.html">Symbol</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IDescribedTypeDecoder.html#acdf75682b5a1a1b96f19ec1121eb3abd">DescriptorSymbol</a><code> [get]</code></td></tr>
<tr class="memdesc:acdf75682b5a1a1b96f19ec1121eb3abd inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IDescribedTypeDecoder"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns an AMQP Symbol code that describes the type to be decoded  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IDescribedTypeDecoder.html#acdf75682b5a1a1b96f19ec1121eb3abd">More...</a><br /></td></tr>
<tr class="separator:acdf75682b5a1a1b96f19ec1121eb3abd inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IDescribedTypeDecoder"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ab0cbe9b903e3869f01806a800b3495b7 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IDescribedTypeDecoder"><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_1Codec_1_1IDescribedTypeDecoder.html#ab0cbe9b903e3869f01806a800b3495b7">DescriptorCode</a><code> [get]</code></td></tr>
<tr class="memdesc:ab0cbe9b903e3869f01806a800b3495b7 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IDescribedTypeDecoder"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns an AMQP unsigned int numeric code that describes the type to be decoded  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IDescribedTypeDecoder.html#ab0cbe9b903e3869f01806a800b3495b7">More...</a><br /></td></tr>
<tr class="separator:ab0cbe9b903e3869f01806a800b3495b7 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IDescribedTypeDecoder"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="inherit_header properties_interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1ITypeDecoder"><td colspan="2" onclick="javascript:toggleInherit('properties_interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1ITypeDecoder')"><img src="closed.png" alt="-"/>&#160;Properties inherited from <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1ITypeDecoder.html">Apache.Qpid.Proton.Codec.ITypeDecoder</a></td></tr>
<tr class="memitem:a1e225b8345bc9013952baca1f1001ca2 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1ITypeDecoder"><td class="memItemLeft" align="right" valign="top">Type&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1ITypeDecoder.html#a1e225b8345bc9013952baca1f1001ca2">DecodesType</a><code> [get]</code></td></tr>
<tr class="memdesc:a1e225b8345bc9013952baca1f1001ca2 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1ITypeDecoder"><td class="mdescLeft">&#160;</td><td class="mdescRight">The Type that this decoder can read.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1ITypeDecoder.html#a1e225b8345bc9013952baca1f1001ca2">More...</a><br /></td></tr>
<tr class="separator:a1e225b8345bc9013952baca1f1001ca2 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1ITypeDecoder"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:afe5d5a6c937634d0908c1b22e320cfeb inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1ITypeDecoder"><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_1Codec_1_1ITypeDecoder.html#afe5d5a6c937634d0908c1b22e320cfeb">IsArrayType</a><code> [get]</code></td></tr>
<tr class="memdesc:afe5d5a6c937634d0908c1b22e320cfeb inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1ITypeDecoder"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns true if the value that this decoder is going to read is an array type.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1ITypeDecoder.html#afe5d5a6c937634d0908c1b22e320cfeb">More...</a><br /></td></tr>
<tr class="separator:afe5d5a6c937634d0908c1b22e320cfeb inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1ITypeDecoder"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="inherit_header properties_interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IStreamDescribedTypeDecoder"><td colspan="2" onclick="javascript:toggleInherit('properties_interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IStreamDescribedTypeDecoder')"><img src="closed.png" alt="-"/>&#160;Properties inherited from <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IStreamDescribedTypeDecoder.html">Apache.Qpid.Proton.Codec.IStreamDescribedTypeDecoder</a></td></tr>
<tr class="memitem:aaf3ed6a55941eab6e70ecf17e69ef017 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IStreamDescribedTypeDecoder"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Types_1_1Symbol.html">Symbol</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IStreamDescribedTypeDecoder.html#aaf3ed6a55941eab6e70ecf17e69ef017">DescriptorSymbol</a><code> [get]</code></td></tr>
<tr class="memdesc:aaf3ed6a55941eab6e70ecf17e69ef017 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IStreamDescribedTypeDecoder"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns an AMQP Symbol code that describes the type to be decoded  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IStreamDescribedTypeDecoder.html#aaf3ed6a55941eab6e70ecf17e69ef017">More...</a><br /></td></tr>
<tr class="separator:aaf3ed6a55941eab6e70ecf17e69ef017 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IStreamDescribedTypeDecoder"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a978e5e401c5ec534953dbc1b385190fe inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IStreamDescribedTypeDecoder"><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_1Codec_1_1IStreamDescribedTypeDecoder.html#a978e5e401c5ec534953dbc1b385190fe">DescriptorCode</a><code> [get]</code></td></tr>
<tr class="memdesc:a978e5e401c5ec534953dbc1b385190fe inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IStreamDescribedTypeDecoder"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns an AMQP unsigned int numeric code that describes the type to be decoded  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IStreamDescribedTypeDecoder.html#a978e5e401c5ec534953dbc1b385190fe">More...</a><br /></td></tr>
<tr class="separator:a978e5e401c5ec534953dbc1b385190fe inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IStreamDescribedTypeDecoder"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="inherit_header properties_interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IStreamTypeDecoder"><td colspan="2" onclick="javascript:toggleInherit('properties_interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IStreamTypeDecoder')"><img src="closed.png" alt="-"/>&#160;Properties inherited from <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IStreamTypeDecoder.html">Apache.Qpid.Proton.Codec.IStreamTypeDecoder</a></td></tr>
<tr class="memitem:ab16bfa3ea4ff85b25b66c33255ad42a1 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IStreamTypeDecoder"><td class="memItemLeft" align="right" valign="top">Type&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IStreamTypeDecoder.html#ab16bfa3ea4ff85b25b66c33255ad42a1">DecodesType</a><code> [get]</code></td></tr>
<tr class="memdesc:ab16bfa3ea4ff85b25b66c33255ad42a1 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IStreamTypeDecoder"><td class="mdescLeft">&#160;</td><td class="mdescRight">The Type that this decoder can read.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IStreamTypeDecoder.html#ab16bfa3ea4ff85b25b66c33255ad42a1">More...</a><br /></td></tr>
<tr class="separator:ab16bfa3ea4ff85b25b66c33255ad42a1 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IStreamTypeDecoder"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ac9f93c7fbc6ad5e341979a26508c668b inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IStreamTypeDecoder"><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_1Codec_1_1IStreamTypeDecoder.html#ac9f93c7fbc6ad5e341979a26508c668b">IsArrayType</a><code> [get]</code></td></tr>
<tr class="memdesc:ac9f93c7fbc6ad5e341979a26508c668b inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IStreamTypeDecoder"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns true if the value that this decoder is going to read is an array type.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IStreamTypeDecoder.html#ac9f93c7fbc6ad5e341979a26508c668b">More...</a><br /></td></tr>
<tr class="separator:ac9f93c7fbc6ad5e341979a26508c668b inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IStreamTypeDecoder"><td class="memSeparator" colspan="2">&#160;</td></tr>
</table>
<h2 class="groupheader">Member Function Documentation</h2>
<a id="a078588562887751293d3da82f98d340d"></a>
<h2 class="memtitle"><span class="permalink"><a href="#a078588562887751293d3da82f98d340d">&#9670;&nbsp;</a></span>ReadArrayElements() <span class="overload">[1/2]</span></h2>

<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">abstract Array Apache.Qpid.Proton.Codec.Decoders.AbstractDescribedTypeDecoder.ReadArrayElements </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>buffer</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IDecoderState.html">IDecoderState</a>&#160;</td>
          <td class="paramname"><em>state</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>count</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">pure virtual</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Reads a series of this type that have been encoded into the body of an Array type. When encoded into an array the values are encoded in series following the identifier for the type, this method is given a count of the number of instances that are encoded and should read each in succession and returning them in a new array. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">buffer</td><td>The buffer where the encoded bytes can be read from</td></tr>
    <tr><td class="paramname">state</td><td>The decoder state that can be used during decode</td></tr>
    <tr><td class="paramname">count</td><td>the number of elements that the encoded array contains</td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>The decoded array from the given buffer</dd></dl>

<p>Implements <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1ITypeDecoder.html#ac73571255b2b779bdc4bddf4d399e5d2">Apache.Qpid.Proton.Codec.ITypeDecoder</a>.</p>

<p>Implemented in <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1UnknownDescribedTypeDecoder.html#a768fbec154c1fff4108f04b1c69c8546">Apache.Qpid.Proton.Codec.Decoders.UnknownDescribedTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1TransferTypeDecoder.html#a99992726ff2312c9ec5628e703ffbd72">Apache.Qpid.Proton.Codec.Decoders.Transport.TransferTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1OpenTypeDecoder.html#a84f53e2d0144fbf1d927b8631083e576">Apache.Qpid.Proton.Codec.Decoders.Transport.OpenTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1FlowTypeDecoder.html#aeed84df3e21ad1aae61cfa2fd20d9a36">Apache.Qpid.Proton.Codec.Decoders.Transport.FlowTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1ErrorConditionTypeDecoder.html#a1c2684aa022cb8ffb1ec981ce98f49ca">Apache.Qpid.Proton.Codec.Decoders.Transport.ErrorConditionTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1EndTypeDecoder.html#a7cc4c36b8da6f8a5b8ebae23910f2e43">Apache.Qpid.Proton.Codec.Decoders.Transport.EndTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1DispositionTypeDecoder.html#a7e03e282d0871d1f120715428591a913">Apache.Qpid.Proton.Codec.Decoders.Transport.DispositionTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1DetachTypeDecoder.html#a353624ae19ef744dab26f9955fc8658c">Apache.Qpid.Proton.Codec.Decoders.Transport.DetachTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1CloseTypeDecoder.html#a2cd99db4109bd6d448f32ca9a9655570">Apache.Qpid.Proton.Codec.Decoders.Transport.CloseTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1BeginTypeDecoder.html#a93abf0ca7bf393674a105621b6cbc911">Apache.Qpid.Proton.Codec.Decoders.Transport.BeginTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1AttachTypeDecoder.html#a463a1e0a282b565e21974c9cce9e1f63">Apache.Qpid.Proton.Codec.Decoders.Transport.AttachTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transactions_1_1TransactionalStateTypeDecoder.html#a123e29738315cc2ae65b0c6f908cbdb0">Apache.Qpid.Proton.Codec.Decoders.Transactions.TransactionalStateTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transactions_1_1DischargeTypeDecoder.html#abd0c0fb585c63f1c4774ff5dcf549f61">Apache.Qpid.Proton.Codec.Decoders.Transactions.DischargeTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transactions_1_1DeclareTypeDecoder.html#ad2d7ef1a10602497b250585cb3f90f59">Apache.Qpid.Proton.Codec.Decoders.Transactions.DeclareTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transactions_1_1DeclaredTypeDecoder.html#a07a6d2b1b2d5c85e1dc32bcdbbe8b482">Apache.Qpid.Proton.Codec.Decoders.Transactions.DeclaredTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transactions_1_1CoordinatorTypeDecoder.html#ae129bdc183ba87be973ca17301023831">Apache.Qpid.Proton.Codec.Decoders.Transactions.CoordinatorTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Security_1_1SaslResponseTypeDecoder.html#a065cb68f3934b164ec77cd1fe6ad6d3c">Apache.Qpid.Proton.Codec.Decoders.Security.SaslResponseTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Security_1_1SaslOutcomeTypeDecoder.html#a23a7ac0de5403e8697bd023ae00492e8">Apache.Qpid.Proton.Codec.Decoders.Security.SaslOutcomeTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Security_1_1SaslMechanismsTypeDecoder.html#aa535f877faa71067aa5bb840d717a8fe">Apache.Qpid.Proton.Codec.Decoders.Security.SaslMechanismsTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Security_1_1SaslInitTypeDecoder.html#aa30762fda2919467d81978bd299b5f0c">Apache.Qpid.Proton.Codec.Decoders.Security.SaslInitTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Security_1_1SaslChallengeTypeDecoder.html#abbcbf36a25095939eedb88f0e3b680ab">Apache.Qpid.Proton.Codec.Decoders.Security.SaslChallengeTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1TargetTypeDecoder.html#a2fc8f73d9c0e4dea2e35fea713211561">Apache.Qpid.Proton.Codec.Decoders.Messaging.TargetTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1SourceTypeDecoder.html#a17002efe2ef4e7de013971d288405403">Apache.Qpid.Proton.Codec.Decoders.Messaging.SourceTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1ReleasedTypeDecoder.html#a691add89ce5553bc9d556137355ef85e">Apache.Qpid.Proton.Codec.Decoders.Messaging.ReleasedTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1RejectedTypeDecoder.html#abbd0b06cb9eb32c7c048ddbc4915de41">Apache.Qpid.Proton.Codec.Decoders.Messaging.RejectedTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1ReceivedTypeDecoder.html#a250eeba477edbd8c786d3e4bfe91b559">Apache.Qpid.Proton.Codec.Decoders.Messaging.ReceivedTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1PropertiesTypeDecoder.html#ad55badae428eedbdaf713764f426d9a0">Apache.Qpid.Proton.Codec.Decoders.Messaging.PropertiesTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1ModifiedTypeDecoder.html#adbd5bd290a1eeb5851987ec04e56a2b5">Apache.Qpid.Proton.Codec.Decoders.Messaging.ModifiedTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1MessageAnnotationsTypeDecoder.html#a5b32776f29bd32617e2980a8555a77c0">Apache.Qpid.Proton.Codec.Decoders.Messaging.MessageAnnotationsTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1HeaderTypeDecoder.html#a697cb9dc83ebc543adf19ff764bd6eb9">Apache.Qpid.Proton.Codec.Decoders.Messaging.HeaderTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1FooterTypeDecoder.html#a06f62fe173ecda43edfa9eb58970da51">Apache.Qpid.Proton.Codec.Decoders.Messaging.FooterTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1DeliveryAnnotationsTypeDecoder.html#a8c3e7d0b70d1121f0534f432d6e287c5">Apache.Qpid.Proton.Codec.Decoders.Messaging.DeliveryAnnotationsTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1DeleteOnNoMessagesTypeDecoder.html#ae5331c2426c65ebfdfa679b65f2ec071">Apache.Qpid.Proton.Codec.Decoders.Messaging.DeleteOnNoMessagesTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1DeleteOnNoLinksTypeDecoder.html#a0c43b49bc1cc7c925eb9a75ee30970db">Apache.Qpid.Proton.Codec.Decoders.Messaging.DeleteOnNoLinksTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1DeleteOnNoLinksOrMessagesTypeDecoder.html#a04ab7df32223942d22de610d8b86df65">Apache.Qpid.Proton.Codec.Decoders.Messaging.DeleteOnNoLinksOrMessagesTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1DeleteOnCloseTypeDecoder.html#ac0e8896d5366d3ff566989e9b7986efd">Apache.Qpid.Proton.Codec.Decoders.Messaging.DeleteOnCloseTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1DataTypeDecoder.html#ab11f88d234b6174e3ceab8f3ef50f76f">Apache.Qpid.Proton.Codec.Decoders.Messaging.DataTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1ApplicationPropertiesTypeDecoder.html#aa83865e4c1ea5738a2864d8abd9a5cfa">Apache.Qpid.Proton.Codec.Decoders.Messaging.ApplicationPropertiesTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1AmqpValueTypeDecoder.html#a462abe890f0d17d1e143206d64cf9c59">Apache.Qpid.Proton.Codec.Decoders.Messaging.AmqpValueTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1AmqpSequenceTypeDecoder.html#ac10e46a8dbb61fa4df7fce13c9333bf6">Apache.Qpid.Proton.Codec.Decoders.Messaging.AmqpSequenceTypeDecoder</a>, and <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1AcceptedTypeDecoder.html#a350b7bfed32899e62f30e291ea82270c">Apache.Qpid.Proton.Codec.Decoders.Messaging.AcceptedTypeDecoder</a>.</p>

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

<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">abstract Array Apache.Qpid.Proton.Codec.Decoders.AbstractDescribedTypeDecoder.ReadArrayElements </td>
          <td>(</td>
          <td class="paramtype">Stream&#160;</td>
          <td class="paramname"><em>stream</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IStreamDecoderState.html">IStreamDecoderState</a>&#160;</td>
          <td class="paramname"><em>state</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int&#160;</td>
          <td class="paramname"><em>count</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">pure virtual</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Reads a series of this type that have been encoded into the body of an Array type. When encoded into an array the values are encoded in series following the identifier for the type, this method is given a count of the number of instances that are encoded and should read each in succession and returning them in a new array. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">stream</td><td>The stream where the encoded bytes can be read from</td></tr>
    <tr><td class="paramname">state</td><td>The decoder state that can be used during decode</td></tr>
    <tr><td class="paramname">count</td><td>the number of elements that the encoded array contains</td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>The decoded array from the given stream</dd></dl>

<p>Implements <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IStreamTypeDecoder.html#ab7753ca60ebc82757bab0d6b0eec282f">Apache.Qpid.Proton.Codec.IStreamTypeDecoder</a>.</p>

<p>Implemented in <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1UnknownDescribedTypeDecoder.html#a23c15fb49ea321276f88c03cbc60bf48">Apache.Qpid.Proton.Codec.Decoders.UnknownDescribedTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1TransferTypeDecoder.html#a565215dd313b51b79035e76b78677e7c">Apache.Qpid.Proton.Codec.Decoders.Transport.TransferTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1OpenTypeDecoder.html#a50d12cd3a93a4a8d94392cd31cf96a11">Apache.Qpid.Proton.Codec.Decoders.Transport.OpenTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1FlowTypeDecoder.html#a2f789f54f305a895cdf697a15561c71d">Apache.Qpid.Proton.Codec.Decoders.Transport.FlowTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1ErrorConditionTypeDecoder.html#ab5cd0259d10badc03458caa8a19c3b03">Apache.Qpid.Proton.Codec.Decoders.Transport.ErrorConditionTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1EndTypeDecoder.html#ad9c8d096091fa63c38f15809933f5e7a">Apache.Qpid.Proton.Codec.Decoders.Transport.EndTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1DispositionTypeDecoder.html#a33dabfa627d66611fe57f8920169f88c">Apache.Qpid.Proton.Codec.Decoders.Transport.DispositionTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1DetachTypeDecoder.html#a6c1adf7c5df574f02ab9e13669278d76">Apache.Qpid.Proton.Codec.Decoders.Transport.DetachTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1CloseTypeDecoder.html#afce63ab87bb07d23fc8fd1b635847411">Apache.Qpid.Proton.Codec.Decoders.Transport.CloseTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1BeginTypeDecoder.html#adb4e57ff7bad102fc595ba665e0d032c">Apache.Qpid.Proton.Codec.Decoders.Transport.BeginTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1AttachTypeDecoder.html#aae1ee1629ee05dfd2c6ff905a95ec137">Apache.Qpid.Proton.Codec.Decoders.Transport.AttachTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transactions_1_1TransactionalStateTypeDecoder.html#ad95033cb1509ad5fed5c3a228adcce15">Apache.Qpid.Proton.Codec.Decoders.Transactions.TransactionalStateTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transactions_1_1DischargeTypeDecoder.html#a0aaa87fd2e5f12c5cf0cc183f31aa201">Apache.Qpid.Proton.Codec.Decoders.Transactions.DischargeTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transactions_1_1DeclareTypeDecoder.html#a38f33fdc77a0fdf31b8b8426263ffc76">Apache.Qpid.Proton.Codec.Decoders.Transactions.DeclareTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transactions_1_1DeclaredTypeDecoder.html#a373f1fc2eb69fb10c1b62cdd44efbe89">Apache.Qpid.Proton.Codec.Decoders.Transactions.DeclaredTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transactions_1_1CoordinatorTypeDecoder.html#adc7a8108e626b38563fa68c0053b7cac">Apache.Qpid.Proton.Codec.Decoders.Transactions.CoordinatorTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Security_1_1SaslResponseTypeDecoder.html#ac06d387e6a36e852e07e541f30fa04af">Apache.Qpid.Proton.Codec.Decoders.Security.SaslResponseTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Security_1_1SaslOutcomeTypeDecoder.html#a216aa613eaaeaa36610cefe2e5854908">Apache.Qpid.Proton.Codec.Decoders.Security.SaslOutcomeTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Security_1_1SaslMechanismsTypeDecoder.html#a19dfb3520d9d902a62cea146a18abaa9">Apache.Qpid.Proton.Codec.Decoders.Security.SaslMechanismsTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Security_1_1SaslInitTypeDecoder.html#a089222ba4370fdd8ab69b2b42c32db8c">Apache.Qpid.Proton.Codec.Decoders.Security.SaslInitTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Security_1_1SaslChallengeTypeDecoder.html#ab5a2297c908ae2f0b1f4095811650271">Apache.Qpid.Proton.Codec.Decoders.Security.SaslChallengeTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1TargetTypeDecoder.html#aff531c994140d089699174806bb73845">Apache.Qpid.Proton.Codec.Decoders.Messaging.TargetTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1SourceTypeDecoder.html#a07485b1175350a1cb29c8c7eacea0452">Apache.Qpid.Proton.Codec.Decoders.Messaging.SourceTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1ReleasedTypeDecoder.html#a153dac2c9adce82a29768aeb8e383257">Apache.Qpid.Proton.Codec.Decoders.Messaging.ReleasedTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1RejectedTypeDecoder.html#a2bcc511bf4431b8672d33fe494b9afba">Apache.Qpid.Proton.Codec.Decoders.Messaging.RejectedTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1ReceivedTypeDecoder.html#a50e788e1b720795a36834a99b4155020">Apache.Qpid.Proton.Codec.Decoders.Messaging.ReceivedTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1PropertiesTypeDecoder.html#a5cf461d42a07274ca26bdb9294c4e2d1">Apache.Qpid.Proton.Codec.Decoders.Messaging.PropertiesTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1ModifiedTypeDecoder.html#a6479fa99e29307827134a89c671ab465">Apache.Qpid.Proton.Codec.Decoders.Messaging.ModifiedTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1MessageAnnotationsTypeDecoder.html#ae98335a35a1290487a6367d897c032f7">Apache.Qpid.Proton.Codec.Decoders.Messaging.MessageAnnotationsTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1HeaderTypeDecoder.html#aceffb101bdba907257abffa9938a9a07">Apache.Qpid.Proton.Codec.Decoders.Messaging.HeaderTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1FooterTypeDecoder.html#a8df2c7f4dfec9af012443846f712369a">Apache.Qpid.Proton.Codec.Decoders.Messaging.FooterTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1DeliveryAnnotationsTypeDecoder.html#a70658a03def41a5533c92961e4ff1602">Apache.Qpid.Proton.Codec.Decoders.Messaging.DeliveryAnnotationsTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1DeleteOnNoMessagesTypeDecoder.html#abf0e40307a80a5b3c3f353c8c01e0bc3">Apache.Qpid.Proton.Codec.Decoders.Messaging.DeleteOnNoMessagesTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1DeleteOnNoLinksTypeDecoder.html#aa5a3aa3fb734ccebdc07735193339649">Apache.Qpid.Proton.Codec.Decoders.Messaging.DeleteOnNoLinksTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1DeleteOnNoLinksOrMessagesTypeDecoder.html#a76691377e26c8180e6c72b98d26a7800">Apache.Qpid.Proton.Codec.Decoders.Messaging.DeleteOnNoLinksOrMessagesTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1DeleteOnCloseTypeDecoder.html#a9b6f9859b67d00b7106955727bd20b8c">Apache.Qpid.Proton.Codec.Decoders.Messaging.DeleteOnCloseTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1DataTypeDecoder.html#a01bf27ba008dc0d5707b767a81713694">Apache.Qpid.Proton.Codec.Decoders.Messaging.DataTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1ApplicationPropertiesTypeDecoder.html#aeff30729522fc53186cf2511f8d0f600">Apache.Qpid.Proton.Codec.Decoders.Messaging.ApplicationPropertiesTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1AmqpValueTypeDecoder.html#a36cb02ad2fa21e23a2a6e67c5f693e16">Apache.Qpid.Proton.Codec.Decoders.Messaging.AmqpValueTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1AmqpSequenceTypeDecoder.html#a769f86c48172bdb5ada9d1d02031c161">Apache.Qpid.Proton.Codec.Decoders.Messaging.AmqpSequenceTypeDecoder</a>, and <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1AcceptedTypeDecoder.html#a16aa2c44ea31f7407bfe9d3eb616b700">Apache.Qpid.Proton.Codec.Decoders.Messaging.AcceptedTypeDecoder</a>.</p>

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

<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">abstract object Apache.Qpid.Proton.Codec.Decoders.AbstractDescribedTypeDecoder.ReadValue </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>buffer</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IDecoderState.html">IDecoderState</a>&#160;</td>
          <td class="paramname"><em>state</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">pure virtual</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Reads this decoders managed type from the given buffer and returns it. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">buffer</td><td>The buffer where the encoded bytes can be read from</td></tr>
    <tr><td class="paramname">state</td><td>The decoder state that can be used during decode</td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>The decoded value from the byte stream</dd></dl>

<p>Implements <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1ITypeDecoder.html#a24360aeb06219892be48b737fef2284e">Apache.Qpid.Proton.Codec.ITypeDecoder</a>.</p>

<p>Implemented in <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1UnknownDescribedTypeDecoder.html#a878b6c6498cda8e119f58347d2a99751">Apache.Qpid.Proton.Codec.Decoders.UnknownDescribedTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1TransferTypeDecoder.html#ab0364f67ac4e315c62989eee2aca3e3a">Apache.Qpid.Proton.Codec.Decoders.Transport.TransferTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1OpenTypeDecoder.html#a8d4e4f508a6d9395e2a074430b9f5c75">Apache.Qpid.Proton.Codec.Decoders.Transport.OpenTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1FlowTypeDecoder.html#a123d4026e51167397f9b0ce5502ccaca">Apache.Qpid.Proton.Codec.Decoders.Transport.FlowTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1ErrorConditionTypeDecoder.html#a676c66f19fbcd2e6dc2bd290bb8af79b">Apache.Qpid.Proton.Codec.Decoders.Transport.ErrorConditionTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1EndTypeDecoder.html#ac0053aa2b77a9e90b99846fc0735bda3">Apache.Qpid.Proton.Codec.Decoders.Transport.EndTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1DispositionTypeDecoder.html#a674a674e58efa98181090d71c8868f03">Apache.Qpid.Proton.Codec.Decoders.Transport.DispositionTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1DetachTypeDecoder.html#a72d43c73e8f568f534fb238d824eded4">Apache.Qpid.Proton.Codec.Decoders.Transport.DetachTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1CloseTypeDecoder.html#a8eef55de0d1d2bf29d452caa89f1ce98">Apache.Qpid.Proton.Codec.Decoders.Transport.CloseTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1BeginTypeDecoder.html#a4b3a191398a9b26230be714ad9cfefac">Apache.Qpid.Proton.Codec.Decoders.Transport.BeginTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1AttachTypeDecoder.html#a4e96a64d79d30ea3efe87384889a7880">Apache.Qpid.Proton.Codec.Decoders.Transport.AttachTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transactions_1_1TransactionalStateTypeDecoder.html#aa5297daee487b20241c73029ddbed2c9">Apache.Qpid.Proton.Codec.Decoders.Transactions.TransactionalStateTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transactions_1_1DischargeTypeDecoder.html#a86cde612737d6cfe88514a5152b7c517">Apache.Qpid.Proton.Codec.Decoders.Transactions.DischargeTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transactions_1_1DeclareTypeDecoder.html#afd1e1c47da297806d2e77c24139a9bfd">Apache.Qpid.Proton.Codec.Decoders.Transactions.DeclareTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transactions_1_1DeclaredTypeDecoder.html#a96c9bd5468446088ea79c882909a794a">Apache.Qpid.Proton.Codec.Decoders.Transactions.DeclaredTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transactions_1_1CoordinatorTypeDecoder.html#a1451b758f2290e294c9cfd5c379c1368">Apache.Qpid.Proton.Codec.Decoders.Transactions.CoordinatorTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Security_1_1SaslResponseTypeDecoder.html#a5c91a0dbeccbfe6d7426a5dcf04d4c4f">Apache.Qpid.Proton.Codec.Decoders.Security.SaslResponseTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Security_1_1SaslOutcomeTypeDecoder.html#afdd992477c61c86586d7ca74c88bd797">Apache.Qpid.Proton.Codec.Decoders.Security.SaslOutcomeTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Security_1_1SaslMechanismsTypeDecoder.html#a9407c0c6ac7fcdb078358cb2284e7367">Apache.Qpid.Proton.Codec.Decoders.Security.SaslMechanismsTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Security_1_1SaslInitTypeDecoder.html#aab5592c316b516a915a62dd25edf3e3a">Apache.Qpid.Proton.Codec.Decoders.Security.SaslInitTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Security_1_1SaslChallengeTypeDecoder.html#a27972070f9fa558ec0bcfc507a259e7d">Apache.Qpid.Proton.Codec.Decoders.Security.SaslChallengeTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1TargetTypeDecoder.html#a59f5dc1e62094ad5ac80c75eec98fc9b">Apache.Qpid.Proton.Codec.Decoders.Messaging.TargetTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1SourceTypeDecoder.html#aadfa6e55c7ae6816352aaa0350f15a44">Apache.Qpid.Proton.Codec.Decoders.Messaging.SourceTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1ReleasedTypeDecoder.html#a0c91152869170433bd6e35ce4f5da6c5">Apache.Qpid.Proton.Codec.Decoders.Messaging.ReleasedTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1RejectedTypeDecoder.html#afdf530b72ca0452598bdbd95e065dbdb">Apache.Qpid.Proton.Codec.Decoders.Messaging.RejectedTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1ReceivedTypeDecoder.html#a3cc43da9022951c80203570a5a8848e8">Apache.Qpid.Proton.Codec.Decoders.Messaging.ReceivedTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1PropertiesTypeDecoder.html#ad56637d6118aa99cf9f18eaf430eee43">Apache.Qpid.Proton.Codec.Decoders.Messaging.PropertiesTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1ModifiedTypeDecoder.html#a943f31df52282be7ee8017be189e27e0">Apache.Qpid.Proton.Codec.Decoders.Messaging.ModifiedTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1MessageAnnotationsTypeDecoder.html#a39fda2a4bda6ce4876c4c3546b61457c">Apache.Qpid.Proton.Codec.Decoders.Messaging.MessageAnnotationsTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1HeaderTypeDecoder.html#ad9fe9542d223e5c1459ee230f0b7a9b2">Apache.Qpid.Proton.Codec.Decoders.Messaging.HeaderTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1FooterTypeDecoder.html#a1021cce243e5d687369da53c70dce21a">Apache.Qpid.Proton.Codec.Decoders.Messaging.FooterTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1DeliveryAnnotationsTypeDecoder.html#a5ba9b61718505b1d998204f8479d2270">Apache.Qpid.Proton.Codec.Decoders.Messaging.DeliveryAnnotationsTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1DeleteOnNoMessagesTypeDecoder.html#a6a6cfcab3c34cbcd5d9a1028655aad09">Apache.Qpid.Proton.Codec.Decoders.Messaging.DeleteOnNoMessagesTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1DeleteOnNoLinksTypeDecoder.html#a79fc432804ad024d621871f3cbcdf1cd">Apache.Qpid.Proton.Codec.Decoders.Messaging.DeleteOnNoLinksTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1DeleteOnNoLinksOrMessagesTypeDecoder.html#a5e44962e6469eafbc3c8fa9efd701501">Apache.Qpid.Proton.Codec.Decoders.Messaging.DeleteOnNoLinksOrMessagesTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1DeleteOnCloseTypeDecoder.html#ab20f8ceaa6f88fe502138f778ebaded8">Apache.Qpid.Proton.Codec.Decoders.Messaging.DeleteOnCloseTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1DataTypeDecoder.html#aefa95acbd382be2e26c99207ad69edb5">Apache.Qpid.Proton.Codec.Decoders.Messaging.DataTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1ApplicationPropertiesTypeDecoder.html#a84614bfc3fcda5eed3dd3f2fe00aba75">Apache.Qpid.Proton.Codec.Decoders.Messaging.ApplicationPropertiesTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1AmqpValueTypeDecoder.html#a5a6e3dd6d44d1092d72aea6db43e48e7">Apache.Qpid.Proton.Codec.Decoders.Messaging.AmqpValueTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1AmqpSequenceTypeDecoder.html#a69f0b6290a6dc44c02dbd972faf8d167">Apache.Qpid.Proton.Codec.Decoders.Messaging.AmqpSequenceTypeDecoder</a>, and <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1AcceptedTypeDecoder.html#afe574780394a3cd7e59aa66de915ce14">Apache.Qpid.Proton.Codec.Decoders.Messaging.AcceptedTypeDecoder</a>.</p>

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

<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">abstract object Apache.Qpid.Proton.Codec.Decoders.AbstractDescribedTypeDecoder.ReadValue </td>
          <td>(</td>
          <td class="paramtype">Stream&#160;</td>
          <td class="paramname"><em>stream</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IStreamDecoderState.html">IStreamDecoderState</a>&#160;</td>
          <td class="paramname"><em>state</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">pure virtual</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Reads this decoders managed type from the given buffer and returns it. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">stream</td><td>The stream where the encoded bytes can be read from</td></tr>
    <tr><td class="paramname">state</td><td>The decoder state that can be used during decode</td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>The decoded value from the byte stream</dd></dl>

<p>Implements <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IStreamTypeDecoder.html#a3cd44742be1422ecd74a5a455727a31b">Apache.Qpid.Proton.Codec.IStreamTypeDecoder</a>.</p>

<p>Implemented in <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1UnknownDescribedTypeDecoder.html#a62a8a6b049d4cb3f5104a4acb2a377a5">Apache.Qpid.Proton.Codec.Decoders.UnknownDescribedTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1TransferTypeDecoder.html#ad7973e2c41c03c6d00eb658b2aef1faa">Apache.Qpid.Proton.Codec.Decoders.Transport.TransferTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1OpenTypeDecoder.html#adb3a4916e097685540c08ea8d448b4e9">Apache.Qpid.Proton.Codec.Decoders.Transport.OpenTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1FlowTypeDecoder.html#a59e4c8d685fe62acb8f9be2d4093c999">Apache.Qpid.Proton.Codec.Decoders.Transport.FlowTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1ErrorConditionTypeDecoder.html#acae7444499c07acfe6de134e3dcc21a0">Apache.Qpid.Proton.Codec.Decoders.Transport.ErrorConditionTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1EndTypeDecoder.html#ae14f820215e7a09fa9e389912b2e421c">Apache.Qpid.Proton.Codec.Decoders.Transport.EndTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1DispositionTypeDecoder.html#a4bbe09e2ad89fa9fedf9124a258e6ae6">Apache.Qpid.Proton.Codec.Decoders.Transport.DispositionTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1DetachTypeDecoder.html#a72ba7160a1b0d913e8ac3b96cb77d81e">Apache.Qpid.Proton.Codec.Decoders.Transport.DetachTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1CloseTypeDecoder.html#a26be1561d3087a8da46270b0b0b46457">Apache.Qpid.Proton.Codec.Decoders.Transport.CloseTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1BeginTypeDecoder.html#a6de26d16c2f9439ead9748f66f23dad5">Apache.Qpid.Proton.Codec.Decoders.Transport.BeginTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1AttachTypeDecoder.html#af20abef468650fa4fb47481d3e223159">Apache.Qpid.Proton.Codec.Decoders.Transport.AttachTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transactions_1_1TransactionalStateTypeDecoder.html#a4c397d6fac21dca4deed91cc93efb3dc">Apache.Qpid.Proton.Codec.Decoders.Transactions.TransactionalStateTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transactions_1_1DischargeTypeDecoder.html#a454ad5ceef6c23a5002b65bcfd558e2e">Apache.Qpid.Proton.Codec.Decoders.Transactions.DischargeTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transactions_1_1DeclareTypeDecoder.html#a216c20fa13260d15528b7dcfb847cdab">Apache.Qpid.Proton.Codec.Decoders.Transactions.DeclareTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transactions_1_1DeclaredTypeDecoder.html#a6c4170c0465632ae9f9165fff2aca31d">Apache.Qpid.Proton.Codec.Decoders.Transactions.DeclaredTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transactions_1_1CoordinatorTypeDecoder.html#a8259d2a42a435303a0c5fa68b7a8e68e">Apache.Qpid.Proton.Codec.Decoders.Transactions.CoordinatorTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Security_1_1SaslResponseTypeDecoder.html#a7c03cee2d0f2ad2ba560132eb17be44a">Apache.Qpid.Proton.Codec.Decoders.Security.SaslResponseTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Security_1_1SaslOutcomeTypeDecoder.html#af3b915ae341fe127195bbd61ceaa1f3d">Apache.Qpid.Proton.Codec.Decoders.Security.SaslOutcomeTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Security_1_1SaslMechanismsTypeDecoder.html#add560b9fd140dc7239aec4cb06e067e6">Apache.Qpid.Proton.Codec.Decoders.Security.SaslMechanismsTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Security_1_1SaslInitTypeDecoder.html#a955a80362561f013c81543b0fc8ae8f4">Apache.Qpid.Proton.Codec.Decoders.Security.SaslInitTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Security_1_1SaslChallengeTypeDecoder.html#aba4e74c17b44899f5ef154946d7030fa">Apache.Qpid.Proton.Codec.Decoders.Security.SaslChallengeTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1TargetTypeDecoder.html#a6ebab90c013d360696e82eb6617ffeb7">Apache.Qpid.Proton.Codec.Decoders.Messaging.TargetTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1SourceTypeDecoder.html#ad1353934c9eb0ab39dfd4ba9096d0ecd">Apache.Qpid.Proton.Codec.Decoders.Messaging.SourceTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1ReleasedTypeDecoder.html#a1c5aa52dd87dac59f6b0230be6fc51d2">Apache.Qpid.Proton.Codec.Decoders.Messaging.ReleasedTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1RejectedTypeDecoder.html#a6f01ee565a53f00418f1ab1d9fcade04">Apache.Qpid.Proton.Codec.Decoders.Messaging.RejectedTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1ReceivedTypeDecoder.html#a9f5de7a79121210fc2af8e5d7de9600d">Apache.Qpid.Proton.Codec.Decoders.Messaging.ReceivedTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1PropertiesTypeDecoder.html#a959ceccb3614fdadfe687c7c060ae765">Apache.Qpid.Proton.Codec.Decoders.Messaging.PropertiesTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1ModifiedTypeDecoder.html#acc716c46a1dd139e1d8e075ce878ed39">Apache.Qpid.Proton.Codec.Decoders.Messaging.ModifiedTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1MessageAnnotationsTypeDecoder.html#a8e6e3304aefa9c899c4427f9ca96a9ea">Apache.Qpid.Proton.Codec.Decoders.Messaging.MessageAnnotationsTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1HeaderTypeDecoder.html#aab13e52742f46c61930fd07fc931490f">Apache.Qpid.Proton.Codec.Decoders.Messaging.HeaderTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1FooterTypeDecoder.html#a47a561ba57343a32a80e0facf3e02dac">Apache.Qpid.Proton.Codec.Decoders.Messaging.FooterTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1DeliveryAnnotationsTypeDecoder.html#acd3c3c3787f3ad93f4afe2bbbf84bf52">Apache.Qpid.Proton.Codec.Decoders.Messaging.DeliveryAnnotationsTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1DeleteOnNoMessagesTypeDecoder.html#a76c913876328f8991db513b99965a28b">Apache.Qpid.Proton.Codec.Decoders.Messaging.DeleteOnNoMessagesTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1DeleteOnNoLinksTypeDecoder.html#a2a05790a7a8c58350a0cd28e68f52b4c">Apache.Qpid.Proton.Codec.Decoders.Messaging.DeleteOnNoLinksTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1DeleteOnNoLinksOrMessagesTypeDecoder.html#a6c47f3270ae64d7b475c4b12abb4bb1a">Apache.Qpid.Proton.Codec.Decoders.Messaging.DeleteOnNoLinksOrMessagesTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1DeleteOnCloseTypeDecoder.html#a995402af06e8b978c88072127caed7ee">Apache.Qpid.Proton.Codec.Decoders.Messaging.DeleteOnCloseTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1DataTypeDecoder.html#a1af8bd04af39947db482a11ab2d5a352">Apache.Qpid.Proton.Codec.Decoders.Messaging.DataTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1ApplicationPropertiesTypeDecoder.html#a133b15fd84f1fba14659e4d2fd0091da">Apache.Qpid.Proton.Codec.Decoders.Messaging.ApplicationPropertiesTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1AmqpValueTypeDecoder.html#a7873258a1fbe869858f8e2b56f3e0173">Apache.Qpid.Proton.Codec.Decoders.Messaging.AmqpValueTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1AmqpSequenceTypeDecoder.html#ac57c144a20717e36285a137c6382bb66">Apache.Qpid.Proton.Codec.Decoders.Messaging.AmqpSequenceTypeDecoder</a>, and <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1AcceptedTypeDecoder.html#a5150f14d4bb150d3923a5c22ffbadc9c">Apache.Qpid.Proton.Codec.Decoders.Messaging.AcceptedTypeDecoder</a>.</p>

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

<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">abstract void Apache.Qpid.Proton.Codec.Decoders.AbstractDescribedTypeDecoder.SkipValue </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>buffer</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IDecoderState.html">IDecoderState</a>&#160;</td>
          <td class="paramname"><em>state</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">pure virtual</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Skips the value that this decoder is handling by skipping the encoded bytes in the provided buffer instance. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">buffer</td><td>The buffer where the encoded bytes can be read from</td></tr>
    <tr><td class="paramname">state</td><td>The decoder state that can be used during decode</td></tr>
  </table>
  </dd>
</dl>

<p>Implements <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1ITypeDecoder.html#a13eb3dc3f4ef928c33adfcef4e16032a">Apache.Qpid.Proton.Codec.ITypeDecoder</a>.</p>

<p>Implemented in <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1UnknownDescribedTypeDecoder.html#ab85648e24af519fbd9b1443e679573f3">Apache.Qpid.Proton.Codec.Decoders.UnknownDescribedTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1TransferTypeDecoder.html#a8567c6e3e7bc2844178ec61022370c7f">Apache.Qpid.Proton.Codec.Decoders.Transport.TransferTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1OpenTypeDecoder.html#a12a8940b1f36723329c96175968fcade">Apache.Qpid.Proton.Codec.Decoders.Transport.OpenTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1FlowTypeDecoder.html#ae6d6577a28da60c119df78b15b961fc4">Apache.Qpid.Proton.Codec.Decoders.Transport.FlowTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1ErrorConditionTypeDecoder.html#a895d6ad307a846403fe5256849b46a35">Apache.Qpid.Proton.Codec.Decoders.Transport.ErrorConditionTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1EndTypeDecoder.html#aa7fd17eeffce25dc9e38f4cae3c87efd">Apache.Qpid.Proton.Codec.Decoders.Transport.EndTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1DispositionTypeDecoder.html#a3860ef5ce1afd1a7b279bbbd71768d71">Apache.Qpid.Proton.Codec.Decoders.Transport.DispositionTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1DetachTypeDecoder.html#a91df129f1b4fd953b17e07171834329e">Apache.Qpid.Proton.Codec.Decoders.Transport.DetachTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1CloseTypeDecoder.html#ae8afac7d4bef50b8560d8d2f3513d560">Apache.Qpid.Proton.Codec.Decoders.Transport.CloseTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1BeginTypeDecoder.html#aa960aceab501b47d146d36d59ca44888">Apache.Qpid.Proton.Codec.Decoders.Transport.BeginTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1AttachTypeDecoder.html#aa023a39fa098afb7bc4c2c55adeb4695">Apache.Qpid.Proton.Codec.Decoders.Transport.AttachTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transactions_1_1TransactionalStateTypeDecoder.html#abe75c94b55931b957788660f4a7c2bea">Apache.Qpid.Proton.Codec.Decoders.Transactions.TransactionalStateTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transactions_1_1DischargeTypeDecoder.html#aa4c84dfa14b83b07e7eb34f914017fb5">Apache.Qpid.Proton.Codec.Decoders.Transactions.DischargeTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transactions_1_1DeclareTypeDecoder.html#a5d8fc4748855d1265965323c0000f789">Apache.Qpid.Proton.Codec.Decoders.Transactions.DeclareTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transactions_1_1DeclaredTypeDecoder.html#aa95c5e94a5e06b8d841dc17a46f497cb">Apache.Qpid.Proton.Codec.Decoders.Transactions.DeclaredTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transactions_1_1CoordinatorTypeDecoder.html#a93f9e3773fcac8af8b672e4000a5757a">Apache.Qpid.Proton.Codec.Decoders.Transactions.CoordinatorTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Security_1_1SaslResponseTypeDecoder.html#ac131e603ac68ce4f19fcf80d27d3ce95">Apache.Qpid.Proton.Codec.Decoders.Security.SaslResponseTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Security_1_1SaslOutcomeTypeDecoder.html#a4db3e0a02ad5ce14c1750955df367808">Apache.Qpid.Proton.Codec.Decoders.Security.SaslOutcomeTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Security_1_1SaslMechanismsTypeDecoder.html#a97a0e6d5d741039ca9cb15ec3e7288c9">Apache.Qpid.Proton.Codec.Decoders.Security.SaslMechanismsTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Security_1_1SaslInitTypeDecoder.html#ac5bb9dac4c542d218f4c9eaa988e8e4f">Apache.Qpid.Proton.Codec.Decoders.Security.SaslInitTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Security_1_1SaslChallengeTypeDecoder.html#aafbfba1c86418ab2b319bac099b43b1d">Apache.Qpid.Proton.Codec.Decoders.Security.SaslChallengeTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1TargetTypeDecoder.html#aaa7daaa2e7096a016f9c7ba213e1379c">Apache.Qpid.Proton.Codec.Decoders.Messaging.TargetTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1SourceTypeDecoder.html#a09223378c41d6b0e3622c883d8e72999">Apache.Qpid.Proton.Codec.Decoders.Messaging.SourceTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1ReleasedTypeDecoder.html#ac54da94b389b778c50da6c97a186f7ae">Apache.Qpid.Proton.Codec.Decoders.Messaging.ReleasedTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1RejectedTypeDecoder.html#a1279d48de5471bd92738e766ab869057">Apache.Qpid.Proton.Codec.Decoders.Messaging.RejectedTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1ReceivedTypeDecoder.html#a4595442f2b9d912dc367236f6d3fa21e">Apache.Qpid.Proton.Codec.Decoders.Messaging.ReceivedTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1PropertiesTypeDecoder.html#afdfe173031ee28ef84ea851425c0add5">Apache.Qpid.Proton.Codec.Decoders.Messaging.PropertiesTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1ModifiedTypeDecoder.html#aedfb2a781fefd5482926fe3611cad205">Apache.Qpid.Proton.Codec.Decoders.Messaging.ModifiedTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1MessageAnnotationsTypeDecoder.html#a33a076bb750ad5f003363bf091d5c4da">Apache.Qpid.Proton.Codec.Decoders.Messaging.MessageAnnotationsTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1HeaderTypeDecoder.html#a8c90913e02aadff30f215bcbbe0b3d00">Apache.Qpid.Proton.Codec.Decoders.Messaging.HeaderTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1FooterTypeDecoder.html#ad12b08e45854d17d32d0fa86d940168d">Apache.Qpid.Proton.Codec.Decoders.Messaging.FooterTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1DeliveryAnnotationsTypeDecoder.html#a86403349ef37f1b9a869ae03a2ee09ae">Apache.Qpid.Proton.Codec.Decoders.Messaging.DeliveryAnnotationsTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1DeleteOnNoMessagesTypeDecoder.html#a469a8ff3e3401d498b7b729890b3a1c8">Apache.Qpid.Proton.Codec.Decoders.Messaging.DeleteOnNoMessagesTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1DeleteOnNoLinksTypeDecoder.html#af28c4f98770d832fd087a68ca2b21079">Apache.Qpid.Proton.Codec.Decoders.Messaging.DeleteOnNoLinksTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1DeleteOnNoLinksOrMessagesTypeDecoder.html#a375f7f5a3de7087582c3b1bce502ebd2">Apache.Qpid.Proton.Codec.Decoders.Messaging.DeleteOnNoLinksOrMessagesTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1DeleteOnCloseTypeDecoder.html#a9008458eb9e7f9f60dc70ae0df39ee8f">Apache.Qpid.Proton.Codec.Decoders.Messaging.DeleteOnCloseTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1DataTypeDecoder.html#a27bf6ff30e9ebd193c1c9a90b438c8b4">Apache.Qpid.Proton.Codec.Decoders.Messaging.DataTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1ApplicationPropertiesTypeDecoder.html#a5d8159e56c23d59b735cc1bca09965cf">Apache.Qpid.Proton.Codec.Decoders.Messaging.ApplicationPropertiesTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1AmqpValueTypeDecoder.html#ad303843ba58c8e58d545a7fe2e077c9c">Apache.Qpid.Proton.Codec.Decoders.Messaging.AmqpValueTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1AmqpSequenceTypeDecoder.html#a79d4db955798b5434e34d062418c5730">Apache.Qpid.Proton.Codec.Decoders.Messaging.AmqpSequenceTypeDecoder</a>, and <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1AcceptedTypeDecoder.html#a4942c2ab4f03793eff7e726435713336">Apache.Qpid.Proton.Codec.Decoders.Messaging.AcceptedTypeDecoder</a>.</p>

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

<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">abstract void Apache.Qpid.Proton.Codec.Decoders.AbstractDescribedTypeDecoder.SkipValue </td>
          <td>(</td>
          <td class="paramtype">Stream&#160;</td>
          <td class="paramname"><em>stream</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IStreamDecoderState.html">IStreamDecoderState</a>&#160;</td>
          <td class="paramname"><em>state</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">pure virtual</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Skips the value that this decoder is handling by skipping the encoded bytes in the provided buffer instance. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">stream</td><td>The stream where the encoded bytes can be read from</td></tr>
    <tr><td class="paramname">state</td><td>The decoder state that can be used during decode</td></tr>
  </table>
  </dd>
</dl>

<p>Implements <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IStreamTypeDecoder.html#a08c37e0fd44aa44225a4710e448ed844">Apache.Qpid.Proton.Codec.IStreamTypeDecoder</a>.</p>

<p>Implemented in <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1UnknownDescribedTypeDecoder.html#ad666f14c83fdd6d057a9bed748d7740f">Apache.Qpid.Proton.Codec.Decoders.UnknownDescribedTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1TransferTypeDecoder.html#ae891e66df1be11e3ed9a9c177d7dac52">Apache.Qpid.Proton.Codec.Decoders.Transport.TransferTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1OpenTypeDecoder.html#a054d97d9e2467a1a37e97fa81585c5b2">Apache.Qpid.Proton.Codec.Decoders.Transport.OpenTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1FlowTypeDecoder.html#a1f50d155466d53d9558eca83fff5987a">Apache.Qpid.Proton.Codec.Decoders.Transport.FlowTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1ErrorConditionTypeDecoder.html#a1efc8df95f818114847aab28b08b8269">Apache.Qpid.Proton.Codec.Decoders.Transport.ErrorConditionTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1EndTypeDecoder.html#aed88a255313b1596de505b8537027429">Apache.Qpid.Proton.Codec.Decoders.Transport.EndTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1DispositionTypeDecoder.html#aed5b012ba788bcdb897a8ec1660f8e72">Apache.Qpid.Proton.Codec.Decoders.Transport.DispositionTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1DetachTypeDecoder.html#abf6d39edab59cdca56668bcdcd565f78">Apache.Qpid.Proton.Codec.Decoders.Transport.DetachTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1CloseTypeDecoder.html#a5fde2a9cbdd9abd982994a022ed59b2b">Apache.Qpid.Proton.Codec.Decoders.Transport.CloseTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1BeginTypeDecoder.html#a645bc68c3dcf139788549d913c06a231">Apache.Qpid.Proton.Codec.Decoders.Transport.BeginTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transport_1_1AttachTypeDecoder.html#a5e8e19a55eb89b0fb48306a64bb80c0e">Apache.Qpid.Proton.Codec.Decoders.Transport.AttachTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transactions_1_1TransactionalStateTypeDecoder.html#ab92fedc54d4957359f630c64220776a2">Apache.Qpid.Proton.Codec.Decoders.Transactions.TransactionalStateTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transactions_1_1DischargeTypeDecoder.html#a14398cfdc47e464a0246d59aa0dc30f0">Apache.Qpid.Proton.Codec.Decoders.Transactions.DischargeTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transactions_1_1DeclareTypeDecoder.html#a9e84df805f90c7848d7cecb5a4c9e513">Apache.Qpid.Proton.Codec.Decoders.Transactions.DeclareTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transactions_1_1DeclaredTypeDecoder.html#a12a9023554969f4d1eab87e313dbc082">Apache.Qpid.Proton.Codec.Decoders.Transactions.DeclaredTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Transactions_1_1CoordinatorTypeDecoder.html#a1832ef94a6ee4fd123cc55769132f4e6">Apache.Qpid.Proton.Codec.Decoders.Transactions.CoordinatorTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Security_1_1SaslResponseTypeDecoder.html#ae3a46a04c59a851ab877702d1f7ba5de">Apache.Qpid.Proton.Codec.Decoders.Security.SaslResponseTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Security_1_1SaslOutcomeTypeDecoder.html#a648c2cef00659a96dce55db3176a322e">Apache.Qpid.Proton.Codec.Decoders.Security.SaslOutcomeTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Security_1_1SaslMechanismsTypeDecoder.html#a95e1106b405b341ecbfdb1a0a3ca737e">Apache.Qpid.Proton.Codec.Decoders.Security.SaslMechanismsTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Security_1_1SaslInitTypeDecoder.html#ab52559388233b0fe7c48df4d983461cf">Apache.Qpid.Proton.Codec.Decoders.Security.SaslInitTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Security_1_1SaslChallengeTypeDecoder.html#afc0458d361176a83172a35642eabd3d2">Apache.Qpid.Proton.Codec.Decoders.Security.SaslChallengeTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1TargetTypeDecoder.html#a298c5bf6d072d493513f92faf30887fd">Apache.Qpid.Proton.Codec.Decoders.Messaging.TargetTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1SourceTypeDecoder.html#a60a61a16400862046fe8646ec220bb57">Apache.Qpid.Proton.Codec.Decoders.Messaging.SourceTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1ReleasedTypeDecoder.html#aab58920cd513676456e80e6425f4ab26">Apache.Qpid.Proton.Codec.Decoders.Messaging.ReleasedTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1RejectedTypeDecoder.html#a2fe1aeb09ce7ff58d5461a08958b0d0e">Apache.Qpid.Proton.Codec.Decoders.Messaging.RejectedTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1ReceivedTypeDecoder.html#a1fc0ac52b5cbaff5d71e5d4d4bc6c42b">Apache.Qpid.Proton.Codec.Decoders.Messaging.ReceivedTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1PropertiesTypeDecoder.html#ac1354921ea72b44f2ef777699179e501">Apache.Qpid.Proton.Codec.Decoders.Messaging.PropertiesTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1ModifiedTypeDecoder.html#a778945201bc6f623e14548d1ccf3e0d5">Apache.Qpid.Proton.Codec.Decoders.Messaging.ModifiedTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1MessageAnnotationsTypeDecoder.html#a8aebc910b9422f06955b893540c9d4ea">Apache.Qpid.Proton.Codec.Decoders.Messaging.MessageAnnotationsTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1HeaderTypeDecoder.html#a8e8528a9ce2e38fe9002bc4a10ba4490">Apache.Qpid.Proton.Codec.Decoders.Messaging.HeaderTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1FooterTypeDecoder.html#a0bc31643376f934cbcf6dafd8917fe3f">Apache.Qpid.Proton.Codec.Decoders.Messaging.FooterTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1DeliveryAnnotationsTypeDecoder.html#a19d08d779573904372cb1c0a54b83f75">Apache.Qpid.Proton.Codec.Decoders.Messaging.DeliveryAnnotationsTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1DeleteOnNoMessagesTypeDecoder.html#abb0cb6312ed4f6c6696c414d034a98ba">Apache.Qpid.Proton.Codec.Decoders.Messaging.DeleteOnNoMessagesTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1DeleteOnNoLinksTypeDecoder.html#a53ece287841da3e7585885c194f82c38">Apache.Qpid.Proton.Codec.Decoders.Messaging.DeleteOnNoLinksTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1DeleteOnNoLinksOrMessagesTypeDecoder.html#afcee0e38401944c4be1ae2ee2f14f21d">Apache.Qpid.Proton.Codec.Decoders.Messaging.DeleteOnNoLinksOrMessagesTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1DeleteOnCloseTypeDecoder.html#a464ec1a5038c2164cc9f2d0420f9779f">Apache.Qpid.Proton.Codec.Decoders.Messaging.DeleteOnCloseTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1DataTypeDecoder.html#a31b7353846194d17c9c28c71d1b47b25">Apache.Qpid.Proton.Codec.Decoders.Messaging.DataTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1ApplicationPropertiesTypeDecoder.html#a75fc0ab777d6ac6278bf91b466a40eb9">Apache.Qpid.Proton.Codec.Decoders.Messaging.ApplicationPropertiesTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1AmqpValueTypeDecoder.html#aefdc9a2c6820cee8c275bbd3db9746bd">Apache.Qpid.Proton.Codec.Decoders.Messaging.AmqpValueTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1AmqpSequenceTypeDecoder.html#a936a376c8e4af0f14c7959f78d0c9a21">Apache.Qpid.Proton.Codec.Decoders.Messaging.AmqpSequenceTypeDecoder</a>, and <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Messaging_1_1AcceptedTypeDecoder.html#ab968f6e9e0f0468a7032fc6a595b235c">Apache.Qpid.Proton.Codec.Decoders.Messaging.AcceptedTypeDecoder</a>.</p>

</div>
</div>
<hr/>The documentation for this class was generated from the following file:<ul>
<li>src/Proton/Codec/Decoders/AbstractDescribedTypeDecoder.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>
