<!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.ITypeDecoder 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_1ITypeDecoder.html">ITypeDecoder</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_1ITypeDecoder-members.html">List of all members</a>  </div>
  <div class="headertitle">
<div class="title">Apache.Qpid.Proton.Codec.ITypeDecoder 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_1ITypeDecoder.html#details">More...</a></p>
<div class="dynheader">
Inheritance diagram for Apache.Qpid.Proton.Codec.ITypeDecoder:</div>
<div class="dyncontent">
 <div class="center">
  <img src="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1ITypeDecoder.png" usemap="#Apache.Qpid.Proton.Codec.ITypeDecoder_map" alt=""/>
  <map id="Apache.Qpid.Proton.Codec.ITypeDecoder_map" name="Apache.Qpid.Proton.Codec.ITypeDecoder_map">
<area href="interfaceApache_1_1Qpid_1_1Proton_1_1Codec_1_1IDescribedTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.IDescribedTypeDecoder" shape="rect" coords="0,56,414,80"/>
<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="424,56,838,80"/>
<area href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1AbstractDescribedTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.Decoders.AbstractDescribedTypeDecoder" shape="rect" coords="0,112,414,136"/>
<area href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1AbstractPrimitiveTypeDecoder.html" alt="Apache.Qpid.Proton.Codec.Decoders.AbstractPrimitiveTypeDecoder" shape="rect" coords="848,112,1262,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="848,168,1262,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="848,224,1262,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="848,280,1262,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="848,336,1262,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="848,392,1262,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="848,448,1262,472"/>
  </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:a24360aeb06219892be48b737fef2284e"><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_1ITypeDecoder.html#a24360aeb06219892be48b737fef2284e">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:a24360aeb06219892be48b737fef2284e"><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_1ITypeDecoder.html#a24360aeb06219892be48b737fef2284e">More...</a><br /></td></tr>
<tr class="separator:a24360aeb06219892be48b737fef2284e"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a13eb3dc3f4ef928c33adfcef4e16032a"><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_1ITypeDecoder.html#a13eb3dc3f4ef928c33adfcef4e16032a">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:a13eb3dc3f4ef928c33adfcef4e16032a"><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_1ITypeDecoder.html#a13eb3dc3f4ef928c33adfcef4e16032a">More...</a><br /></td></tr>
<tr class="separator:a13eb3dc3f4ef928c33adfcef4e16032a"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ac73571255b2b779bdc4bddf4d399e5d2"><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_1ITypeDecoder.html#ac73571255b2b779bdc4bddf4d399e5d2">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:ac73571255b2b779bdc4bddf4d399e5d2"><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_1ITypeDecoder.html#ac73571255b2b779bdc4bddf4d399e5d2">More...</a><br /></td></tr>
<tr class="separator:ac73571255b2b779bdc4bddf4d399e5d2"><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:a1e225b8345bc9013952baca1f1001ca2"><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"><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"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:afe5d5a6c937634d0908c1b22e320cfeb"><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"><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"><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="ac73571255b2b779bdc4bddf4d399e5d2"></a>
<h2 class="memtitle"><span class="permalink"><a href="#ac73571255b2b779bdc4bddf4d399e5d2">&#9670;&nbsp;</a></span>ReadArrayElements()</h2>

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

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

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">object Apache.Qpid.Proton.Codec.ITypeDecoder.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>
</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>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_1Primitives_1_1UuidTypeDecoder.html#acc476f6cd0eb68700971bb6ded9762c5">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#a12f353094d691ffb8e7bbedb09980392">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#a664f489727b1d1a6e5a09dde85128dd9">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#ac3faed3f434eff499c8af3ba7ffc9f22">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#aa0dc811105eb79ddc961a6bf56731a45">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#a4eaf60bf94560b90a617a85aafa85732">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#a74fc5ffa995b4f874e3575fac388f3df">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#afc86ac6230fc0097a37a3cfdbc57601f">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#afd9d72584b06fcf3a6a3f06771da2be6">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#a1e5c9a23487aa23276fe5d3d9feeb45f">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#a79002db49a73f5a2d7145814465e4c7e">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#a4ac734f8701827cc7ff0f1c33e65cda6">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#a3f6d8bbd6a81dd3b4a2a7e695f03b5ed">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#a7ebc69ef5daaed9621317dff78b7280d">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#a34a025d3bb6bca4b4d2b91c059f102e1">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#af919580e5495d3ad56054a2419b33342">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#a81d061258785c00b2feaa9de239f898b">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#a2bb8e167321177cca8ede0797da86471">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#a91baad3e34a065d25aed6ee739d6effd">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#a222c6304c2ac6922247e5ad2aef64f6b">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#a60ad7351ea8ea23c1ed1739d11a6a442">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#ad4ed46780bde83e98da9b6ae9911b2ee">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#a96c2cd664508adc9f41a377e7f5e8f83">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#ae902822e27610ecf112b256f27682ca3">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#a93b89d2808d3d8a76601e683ad83e535">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#aeb80f4c8e029ceb44a32eff282ba2093">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#af155e992de2075ed1555e4549edf1a7a">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#ae14e34c23469768dc320726979d0048d">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#acf151622f177261ce5b56805e844b662">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#ae319cceb13463c5d9a6a5d454b03e836">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#a9f0a367bd116acf851709a4a3c545fcd">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#ae6a5e29af77aea96daca0ab355f2ad77">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#aeeade5adfc4d504593bc15119d93de27">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#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>, <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>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1AbstractPrimitiveTypeDecoder.html#a43c9cd6d676cb85212b588fb77b3784f">Apache.Qpid.Proton.Codec.Decoders.AbstractPrimitiveTypeDecoder</a>, and <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1AbstractDescribedTypeDecoder.html#ae061aa7e7f5a77704427df3f5f3b0ced">Apache.Qpid.Proton.Codec.Decoders.AbstractDescribedTypeDecoder</a>.</p>

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

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void Apache.Qpid.Proton.Codec.ITypeDecoder.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>
</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>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_1Primitives_1_1UuidTypeDecoder.html#a064756bff9ce8b866d222fa0f7bb0190">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#a358fd4c3988d8a1e38d9542ef92fb68a">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#ad8fe3d5008dbf90edccc18377859c92d">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#afad1d3a017bd946605c487a3be4a2d07">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#aeee5850f2a3bce3507eace54b5f6657d">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#af61a41de21cca6e1a6bd7d235e976bff">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#af130b0ab691a4ac28d29ca76375a9dbc">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#af5e0d72b29e634136fe2bfac202d5ce3">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#af8098a1cc205b241d0c1cfec6ef3d4ef">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#a52abe04c6a6cffe72490634b933cbb53">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#a1e2bb86a6c7638e7186cdae862e4289c">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#aabce71de1e6d52249b2dff6cfaf4db86">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#ae8f4f2f288d4389310789ac918fcb151">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#a87d616f70c42a48fc5594260d3cdc742">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#a915291808d6e5347f80d6b2651a87315">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#a4251880ee82d3d7e8ce6eebaeab6e2b0">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#aa810b7b6f9dba7aa5cde03714785adb5">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#aa3d2587e2ccc73fd414c43e21f3f55d8">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#ad8c00553edebecd71e6c21edee052804">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#a84c543544a3e7740ec47496368dcdd20">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#a0b39789c0aed1f1029f2ec8dedecb1f3">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#a889daf05d5584656c30c6be66fb69b69">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#abfb9a52f74dc9ba0ad536658c726b4d8">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#a6dcd4db76f4f3c7b9395d9c8a5496931">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#abd55fccc5f055bae9f48decdb5405e06">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#a3b18ab3652c479ecb3c8d1b439229756">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#ab78a5eb76ed417be1e86e57ca4a2834a">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#a84d8b9a1ab0066d818a961bf67db4d4d">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#a6caf786c4ea38f254cdc92f4a6e080fb">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#a673f5ba976765d0a894cca03df2aecc2">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#acf005e35abcc52c81a487774574458e4">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#ab4b9ed59c3b605e91e84343c5b13d4f4">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#affa66d7e5df3d446c338d0d07df313d9">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#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>, <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>, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1AbstractPrimitiveTypeDecoder.html#a5374dae99ab1666d1da5e44b8c941ea5">Apache.Qpid.Proton.Codec.Decoders.AbstractPrimitiveTypeDecoder</a>, and <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Codec_1_1Decoders_1_1AbstractDescribedTypeDecoder.html#a9f4e9646f8bfc875211d08d22b9deb83">Apache.Qpid.Proton.Codec.Decoders.AbstractDescribedTypeDecoder</a>.</p>

</div>
</div>
<h2 class="groupheader">Property Documentation</h2>
<a id="a1e225b8345bc9013952baca1f1001ca2"></a>
<h2 class="memtitle"><span class="permalink"><a href="#a1e225b8345bc9013952baca1f1001ca2">&#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.ITypeDecoder.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="afe5d5a6c937634d0908c1b22e320cfeb"></a>
<h2 class="memtitle"><span class="permalink"><a href="#afe5d5a6c937634d0908c1b22e320cfeb">&#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.ITypeDecoder.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/ITypeDecoder.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>
