<!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.IStreamTypeDecoder Interface Reference</title>
<link href="tabs.css" rel="stylesheet" type="text/css"/>
<script type="text/javascript" src="jquery.js"></script>
<script type="text/javascript" src="dynsections.js"></script>
<link href="search/search.css" rel="stylesheet" type="text/css"/>
<script type="text/javascript" src="search/searchdata.js"></script>
<script type="text/javascript" src="search/search.js"></script>
<link href="doxygen.css" rel="stylesheet" type="text/css" />
</head>
<body>
<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
<div id="titlearea">
<table cellspacing="0" cellpadding="0">
 <tbody>
 <tr style="height: 56px;">
  <td id="projectalign" style="padding-left: 0.5em;">
   <div id="projectname">Proton DotNet
   </div>
  </td>
 </tr>
 </tbody>
</table>
</div>
<!-- end header part -->
<!-- Generated by Doxygen 1.9.1 -->
<script type="text/javascript">
/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
var searchBox = new SearchBox("searchBox", "search",false,'Search','.html');
/* @license-end */
</script>
<script type="text/javascript" src="menudata.js"></script>
<script type="text/javascript" src="menu.js"></script>
<script type="text/javascript">
/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
$(function() {
  initMenu('',true,false,'search.php','Search');
  $(document).ready(function() { init_search(); });
});
/* @license-end */</script>
<div id="main-nav"></div>
<!-- window showing the filter options -->
<div id="MSearchSelectWindow"
     onmouseover="return searchBox.OnSearchSelectShow()"
     onmouseout="return searchBox.OnSearchSelectHide()"
     onkeydown="return searchBox.OnSearchSelectKey(event)">
</div>

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

<div id="nav-path" class="navpath">
  <ul>
<li class="navelem"><a class="el" href="namespaceApache.html">Apache</a></li><li class="navelem"><a class="el" href="namespaceApache_1_1Qpid.html">Qpid</a></li><li class="navelem"><a class="el" href="namespaceApache_1_1Qpid_1_1Proton.html">Proton</a></li><li class="navelem"><a class="el" href="namespaceApache_1_1Qpid_1_1Proton_1_1Codec.html">Codec</a></li><li class="navelem"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IStreamTypeDecoder.html">IStreamTypeDecoder</a></li>  </ul>
</div>
</div><!-- top -->
<div class="header">
  <div class="summary">
<a href="#pub-methods">Public Member Functions</a> &#124;
<a href="#properties">Properties</a> &#124;
<a href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IStreamTypeDecoder-members.html">List of all members</a>  </div>
  <div class="headertitle">
<div class="title">Apache.Qpid.Proton.Codec.IStreamTypeDecoder Interface Reference</div>  </div>
</div><!--header-->
<div class="contents">

<p>Defines an interface for an decoder of a specific type.  
 <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IStreamTypeDecoder.html#details">More...</a></p>
<div class="dynheader">
Inheritance diagram for Apache.Qpid.Proton.Codec.IStreamTypeDecoder:</div>
<div class="dyncontent">
 <div class="center">
  <img src="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IStreamTypeDecoder.png" usemap="#Apache.Qpid.Proton.Codec.IStreamTypeDecoder_map" alt=""/>
  <map id="Apache.Qpid.Proton.Codec.IStreamTypeDecoder_map" name="Apache.Qpid.Proton.Codec.IStreamTypeDecoder_map">
<area href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IPrimitiveTypeDecoder.html" title="Defines an interface for an decoder of a primitive types" alt="Apache.Qpid.Proton.Codec.IPrimitiveTypeDecoder" shape="rect" coords="0,56,414,80"/>
<area href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IStreamDescribedTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.IStreamDescribedTypeDecoder" shape="rect" coords="848,56,1262,80"/>
<area href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1AbstractPrimitiveTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.Decoders.AbstractPrimitiveTypeDecoder" shape="rect" coords="424,112,838,136"/>
<area href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1IBinaryTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.Decoders.Primitives.IBinaryTypeDecoder" shape="rect" coords="424,168,838,192"/>
<area href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1IListTypeDecoder.html" title="Interface for type decoders that handle AMQP List encodings." alt="Apache.Qpid.Proton.Codec.Decoders.Primitives.IListTypeDecoder" shape="rect" coords="424,224,838,248"/>
<area href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1IMapTypeDecoder.html" title="Interface for type decoders that handle AMQP Map encodings." alt="Apache.Qpid.Proton.Codec.Decoders.Primitives.IMapTypeDecoder" shape="rect" coords="424,280,838,304"/>
<area href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1IStringTypeDecoder.html" title="Interface for type decoders that handle AMQP Map encodings." alt="Apache.Qpid.Proton.Codec.Decoders.Primitives.IStringTypeDecoder" shape="rect" coords="424,336,838,360"/>
<area href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1ISymbolTypeDecoder.html" title="Interface for type decoders that handle AMQP Symbol encodings." alt="Apache.Qpid.Proton.Codec.Decoders.Primitives.ISymbolTypeDecoder" shape="rect" coords="424,392,838,416"/>
<area href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IPrimitiveArrayTypeDecoder.html" title="Defines an interface for an decoder of a primitive array types" alt="Apache.Qpid.Proton.Codec.IPrimitiveArrayTypeDecoder" shape="rect" coords="424,448,838,472"/>
<area href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1AbstractDescribedTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.Decoders.AbstractDescribedTypeDecoder" shape="rect" coords="848,112,1262,136"/>
  </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:a3cd44742be1422ecd74a5a455727a31b"><td class="memItemLeft" align="right" valign="top">object&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IStreamTypeDecoder.html#a3cd44742be1422ecd74a5a455727a31b">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:a3cd44742be1422ecd74a5a455727a31b"><td class="mdescLeft">&#160;</td><td class="mdescRight">Reads this decoders managed type from the given buffer and returns it.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IStreamTypeDecoder.html#a3cd44742be1422ecd74a5a455727a31b">More...</a><br /></td></tr>
<tr class="separator:a3cd44742be1422ecd74a5a455727a31b"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a08c37e0fd44aa44225a4710e448ed844"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IStreamTypeDecoder.html#a08c37e0fd44aa44225a4710e448ed844">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:a08c37e0fd44aa44225a4710e448ed844"><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="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IStreamTypeDecoder.html#a08c37e0fd44aa44225a4710e448ed844">More...</a><br /></td></tr>
<tr class="separator:a08c37e0fd44aa44225a4710e448ed844"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ab7753ca60ebc82757bab0d6b0eec282f"><td class="memItemLeft" align="right" valign="top">Array&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IStreamTypeDecoder.html#ab7753ca60ebc82757bab0d6b0eec282f">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:ab7753ca60ebc82757bab0d6b0eec282f"><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="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IStreamTypeDecoder.html#ab7753ca60ebc82757bab0d6b0eec282f">More...</a><br /></td></tr>
<tr class="separator:ab7753ca60ebc82757bab0d6b0eec282f"><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:ab16bfa3ea4ff85b25b66c33255ad42a1"><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"><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"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ac9f93c7fbc6ad5e341979a26508c668b"><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"><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"><td class="memSeparator" colspan="2">&#160;</td></tr>
</table>
<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
<div class="textblock"><p>Defines an interface for an decoder of a specific type. </p>
</div><h2 class="groupheader">Member Function Documentation</h2>
<a id="ab7753ca60ebc82757bab0d6b0eec282f"></a>
<h2 class="memtitle"><span class="permalink"><a href="#ab7753ca60ebc82757bab0d6b0eec282f">&#9670;&nbsp;</a></span>ReadArrayElements()</h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">Array Apache.Qpid.Proton.Codec.IStreamTypeDecoder.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>
</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>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>, <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>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1AbstractPrimitiveTypeDecoder.html#a17393bf075fc3a5de2b4d60d15c9ec23">Apache.Qpid.Proton.Codec.Decoders.AbstractPrimitiveTypeDecoder</a>, and <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1AbstractDescribedTypeDecoder.html#a968f5195461f8f89b30f7b27f5b041f2">Apache.Qpid.Proton.Codec.Decoders.AbstractDescribedTypeDecoder</a>.</p>

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

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">object Apache.Qpid.Proton.Codec.IStreamTypeDecoder.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>
</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>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_1Primitives_1_1UuidTypeDecoder.html#ad623499b9345a63cdbcc2ab7d68959b2">Apache.Qpid.Proton.Codec.Decoders.Primitives.UuidTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1UnsignedShortTypeDecoder.html#a8c39e715e451994f23b782bec0ef2b13">Apache.Qpid.Proton.Codec.Decoders.Primitives.UnsignedShortTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1UnsignedLong8TypeDecoder.html#aa0d7ca7939869208918763d7a38f6777">Apache.Qpid.Proton.Codec.Decoders.Primitives.UnsignedLong8TypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1UnsignedLong64TypeDecoder.html#a2b0fbd81d26ac59bdd1a45331a31fbbb">Apache.Qpid.Proton.Codec.Decoders.Primitives.UnsignedLong64TypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1UnsignedLong0TypeDecoder.html#a01380e009f92b7f1177b57852015a788">Apache.Qpid.Proton.Codec.Decoders.Primitives.UnsignedLong0TypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1UnsignedInteger8TypeDecoder.html#a320b645f290fc21974bba90bf8701a2d">Apache.Qpid.Proton.Codec.Decoders.Primitives.UnsignedInteger8TypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1UnsignedInteger32TypeDecoder.html#af1eeebd0541022c4c3dd067f2e798bf5">Apache.Qpid.Proton.Codec.Decoders.Primitives.UnsignedInteger32TypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1UnsignedInteger0TypeDecoder.html#a60837fda42979e55aefe9f1666d10896">Apache.Qpid.Proton.Codec.Decoders.Primitives.UnsignedInteger0TypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1UnsignedByteTypeDecoder.html#a6759c992abe659659d382c04b56a06a6">Apache.Qpid.Proton.Codec.Decoders.Primitives.UnsignedByteTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1TimestampTypeDecoder.html#a3c165c2d705f9ab14600c276ad2b1858">Apache.Qpid.Proton.Codec.Decoders.Primitives.TimestampTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1ShortTypeDecoder.html#adfb3412f03445da888564f8bb76e5a73">Apache.Qpid.Proton.Codec.Decoders.Primitives.ShortTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1NullTypeDecoder.html#ac59990ef568cded3a736dd0c9cb030c0">Apache.Qpid.Proton.Codec.Decoders.Primitives.NullTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1Long8TypeDecoder.html#a46a159a652d95f5aa5e4586261ec9c82">Apache.Qpid.Proton.Codec.Decoders.Primitives.Long8TypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1Long32TypeDecoder.html#a2ab7fb1999ca8620c0fa2ce67d756af7">Apache.Qpid.Proton.Codec.Decoders.Primitives.Long32TypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1List0TypeDecoder.html#aaf9798f036b9edb92caef931759c54a0">Apache.Qpid.Proton.Codec.Decoders.Primitives.List0TypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1Integer8TypeDecoder.html#a61ed7165f56ae5e93f96474c94448d6e">Apache.Qpid.Proton.Codec.Decoders.Primitives.Integer8TypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1Integer32TypeDecoder.html#a572d5542604ef38b84fbefa0fa45b302">Apache.Qpid.Proton.Codec.Decoders.Primitives.Integer32TypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1FloatTypeDecoder.html#a7d6f7a9091ca3bb85137b1cefa6a87e2">Apache.Qpid.Proton.Codec.Decoders.Primitives.FloatTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1DoubleTypeDecoder.html#aa8ba4bfeaf9495b131eff134a4e8d8bc">Apache.Qpid.Proton.Codec.Decoders.Primitives.DoubleTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1Decimal64TypeDecoder.html#a4ba7ec620fc39e8fef7585fe43ee079c">Apache.Qpid.Proton.Codec.Decoders.Primitives.Decimal64TypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1Decimal32TypeDecoder.html#ae9f35bee33e23e0f32eb249483653348">Apache.Qpid.Proton.Codec.Decoders.Primitives.Decimal32TypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1Decimal128TypeDecoder.html#a7e800f9401944b75b0c0c8258a345283">Apache.Qpid.Proton.Codec.Decoders.Primitives.Decimal128TypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1CharacterTypeDecoder.html#ad7995b03d1fbfefc5e3abeaae4c3ce8c">Apache.Qpid.Proton.Codec.Decoders.Primitives.CharacterTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1ByteTypeDecoder.html#ac904f0b5791e518fedb17449b29e9306">Apache.Qpid.Proton.Codec.Decoders.Primitives.ByteTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1BooleanTypeDecoder.html#a6f00f3409cd1c4c61528ce5ec34f8051">Apache.Qpid.Proton.Codec.Decoders.Primitives.BooleanTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1BooleanTrueTypeDecoder.html#a1f072feec089ca12a3658564ab078123">Apache.Qpid.Proton.Codec.Decoders.Primitives.BooleanTrueTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1BooleanFalseTypeDecoder.html#a2ba9237df682d10a74df92e350ba038d">Apache.Qpid.Proton.Codec.Decoders.Primitives.BooleanFalseTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1AbstractSymbolTypeDecoder.html#a41f184f451bdf306bfa8eb111eb25bf7">Apache.Qpid.Proton.Codec.Decoders.Primitives.AbstractSymbolTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1AbstractStringTypeDecoder.html#aa0a557052b214053abd35156add5fb0e">Apache.Qpid.Proton.Codec.Decoders.Primitives.AbstractStringTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1AbstractMapTypeDecoder.html#a03c427a55dbbae6ec3d4efd07da7033a">Apache.Qpid.Proton.Codec.Decoders.Primitives.AbstractMapTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1AbstractListTypeDecoder.html#a7910332c81b1c7953bb258c4aae44793">Apache.Qpid.Proton.Codec.Decoders.Primitives.AbstractListTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1AbstractBinaryTypeDecoder.html#acfd3d030b3423c7234dd684782435cb4">Apache.Qpid.Proton.Codec.Decoders.Primitives.AbstractBinaryTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1AbstractArrayTypeDecoder.html#a9b0d508807ab5a58d5b27c91a76dcbb1">Apache.Qpid.Proton.Codec.Decoders.Primitives.AbstractArrayTypeDecoder</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>, <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>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1AbstractPrimitiveTypeDecoder.html#aaa539c94592da6cddde906ed20339f60">Apache.Qpid.Proton.Codec.Decoders.AbstractPrimitiveTypeDecoder</a>, and <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1AbstractDescribedTypeDecoder.html#ad8120a79157b5c227aece3cdd07ccfe3">Apache.Qpid.Proton.Codec.Decoders.AbstractDescribedTypeDecoder</a>.</p>

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

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void Apache.Qpid.Proton.Codec.IStreamTypeDecoder.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>
</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>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_1Primitives_1_1UuidTypeDecoder.html#ac3cf070abd34ea80e5f10435541372dc">Apache.Qpid.Proton.Codec.Decoders.Primitives.UuidTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1UnsignedShortTypeDecoder.html#ad37584c3079d95c56261de40b453dd8f">Apache.Qpid.Proton.Codec.Decoders.Primitives.UnsignedShortTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1UnsignedLong8TypeDecoder.html#ab7f3357301daacbed082d6168f71f9a0">Apache.Qpid.Proton.Codec.Decoders.Primitives.UnsignedLong8TypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1UnsignedLong64TypeDecoder.html#ab2bf5cb5ebdb395937d522fe37d43c89">Apache.Qpid.Proton.Codec.Decoders.Primitives.UnsignedLong64TypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1UnsignedLong0TypeDecoder.html#a501468e52de3186e8b67e25ca409c409">Apache.Qpid.Proton.Codec.Decoders.Primitives.UnsignedLong0TypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1UnsignedInteger8TypeDecoder.html#af07ab8a38f1ba317f4792e0747b4fe06">Apache.Qpid.Proton.Codec.Decoders.Primitives.UnsignedInteger8TypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1UnsignedInteger32TypeDecoder.html#a1be724a5c599b7916192bfbe5513d130">Apache.Qpid.Proton.Codec.Decoders.Primitives.UnsignedInteger32TypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1UnsignedInteger0TypeDecoder.html#a70f7e2e1f9739898d1d33ca44c6117bd">Apache.Qpid.Proton.Codec.Decoders.Primitives.UnsignedInteger0TypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1UnsignedByteTypeDecoder.html#a9db8c797b1d9a11bfef1fd84343082e3">Apache.Qpid.Proton.Codec.Decoders.Primitives.UnsignedByteTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1TimestampTypeDecoder.html#a1454a32589b1b7aa557713adb394857f">Apache.Qpid.Proton.Codec.Decoders.Primitives.TimestampTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1ShortTypeDecoder.html#af50477cb1624eaae519c792ab5e0c474">Apache.Qpid.Proton.Codec.Decoders.Primitives.ShortTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1NullTypeDecoder.html#a9c98e63d7a35bafc11fd6cd3963030fa">Apache.Qpid.Proton.Codec.Decoders.Primitives.NullTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1Long8TypeDecoder.html#a466f24ae21d722d0da0241851ac1069e">Apache.Qpid.Proton.Codec.Decoders.Primitives.Long8TypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1Long32TypeDecoder.html#aec48d44137a7e233b1093808be475317">Apache.Qpid.Proton.Codec.Decoders.Primitives.Long32TypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1List0TypeDecoder.html#a2e5a825db8e257c3cc5076add9dd01a5">Apache.Qpid.Proton.Codec.Decoders.Primitives.List0TypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1Integer8TypeDecoder.html#af735dcf098c8103791ccff9eba7ef024">Apache.Qpid.Proton.Codec.Decoders.Primitives.Integer8TypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1Integer32TypeDecoder.html#a45e95c069b187201949e68c6c8d84a7a">Apache.Qpid.Proton.Codec.Decoders.Primitives.Integer32TypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1FloatTypeDecoder.html#affc15e24a25ed447472699bed1019d11">Apache.Qpid.Proton.Codec.Decoders.Primitives.FloatTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1DoubleTypeDecoder.html#a0c1bab7f8d9211b718acd3e59efcef9b">Apache.Qpid.Proton.Codec.Decoders.Primitives.DoubleTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1Decimal64TypeDecoder.html#ad21b941e0387224c51a12b8df671a6e7">Apache.Qpid.Proton.Codec.Decoders.Primitives.Decimal64TypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1Decimal32TypeDecoder.html#a37dcb4eac38623e4edf8d549208bc0b4">Apache.Qpid.Proton.Codec.Decoders.Primitives.Decimal32TypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1Decimal128TypeDecoder.html#afbe2ee3c88f985abb573137ff8381d9b">Apache.Qpid.Proton.Codec.Decoders.Primitives.Decimal128TypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1CharacterTypeDecoder.html#af0d6ab979492eecca3390c1b6f779e09">Apache.Qpid.Proton.Codec.Decoders.Primitives.CharacterTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1ByteTypeDecoder.html#a7968b7fc67e2e2fe5dc858bf6dd9b236">Apache.Qpid.Proton.Codec.Decoders.Primitives.ByteTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1BooleanTypeDecoder.html#a947abe28c794021aa7d4a57ea10bcfe1">Apache.Qpid.Proton.Codec.Decoders.Primitives.BooleanTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1BooleanTrueTypeDecoder.html#a1f05549c0414e622e7358e7b6fb700e6">Apache.Qpid.Proton.Codec.Decoders.Primitives.BooleanTrueTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1BooleanFalseTypeDecoder.html#adebc605167731f088c7982eaabc1071c">Apache.Qpid.Proton.Codec.Decoders.Primitives.BooleanFalseTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1AbstractSymbolTypeDecoder.html#acc116b2218aac69bd31f6a28dde6f23f">Apache.Qpid.Proton.Codec.Decoders.Primitives.AbstractSymbolTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1AbstractStringTypeDecoder.html#a4c84843742a2a91c8ffaa4fbfaac43e8">Apache.Qpid.Proton.Codec.Decoders.Primitives.AbstractStringTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1AbstractMapTypeDecoder.html#ae7793ce10d8205cb39dbffd2cd8bcdc6">Apache.Qpid.Proton.Codec.Decoders.Primitives.AbstractMapTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1AbstractListTypeDecoder.html#a421a71e637ed7c078f6b2cadd95a8403">Apache.Qpid.Proton.Codec.Decoders.Primitives.AbstractListTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1AbstractBinaryTypeDecoder.html#a6312a473321c5710e2508fc7b1f10d0e">Apache.Qpid.Proton.Codec.Decoders.Primitives.AbstractBinaryTypeDecoder</a>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1Primitives_1_1AbstractArrayTypeDecoder.html#a77e4956ebe3bb0057c9d5924b6a77d55">Apache.Qpid.Proton.Codec.Decoders.Primitives.AbstractArrayTypeDecoder</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>, <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>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1AbstractPrimitiveTypeDecoder.html#a6ce8685f5831da31e88025b4d7e8c235">Apache.Qpid.Proton.Codec.Decoders.AbstractPrimitiveTypeDecoder</a>, and <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1AbstractDescribedTypeDecoder.html#a62838283f58a5298bbabd55f710759b0">Apache.Qpid.Proton.Codec.Decoders.AbstractDescribedTypeDecoder</a>.</p>

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

<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">Type Apache.Qpid.Proton.Codec.IStreamTypeDecoder.DecodesType</td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">get</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>The Type that this decoder can read. </p>
<dl class="section return"><dt>Returns</dt><dd>The Type value that this type decoder decodes</dd></dl>

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

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

<p>Returns true if the value that this decoder is going to read is an array type. </p>
<dl class="section return"><dt>Returns</dt><dd>true if the decoder instance will read an array types</dd></dl>

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