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

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

<div id="nav-path" class="navpath">
  <ul>
<li class="navelem"><a class="el" href="namespaceApache.html">Apache</a></li><li class="navelem"><a class="el" href="namespaceApache_1_1Qpid.html">Qpid</a></li><li class="navelem"><a class="el" href="namespaceApache_1_1Qpid_1_1Proton.html">Proton</a></li><li class="navelem"><a class="el" href="namespaceApache_1_1Qpid_1_1Proton_1_1Engine.html">Engine</a></li><li class="navelem"><a class="el" href="namespaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation.html">Implementation</a></li><li class="navelem"><a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonReceiver.html">ProtonReceiver</a></li>  </ul>
</div>
</div><!-- top -->
<div class="header">
  <div class="summary">
<a href="#pub-methods">Public Member Functions</a> &#124;
<a href="#pro-methods">Protected Member Functions</a> &#124;
<a href="#properties">Properties</a> &#124;
<a href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonReceiver-members.html">List of all members</a>  </div>
  <div class="headertitle">
<div class="title">Apache.Qpid.Proton.Engine.Implementation.ProtonReceiver Class Reference</div>  </div>
</div><!--header-->
<div class="contents">

<p><a class="el" href="namespaceApache_1_1Qpid_1_1Proton.html">Proton</a> Receiver link implementation which manages the receipt of new deliveries and credit associated with the link. Delivery outcomes and settlement states can also be managed from the receiver link.  
 <a href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonReceiver.html#details">More...</a></p>
<div class="dynheader">
Inheritance diagram for Apache.Qpid.Proton.Engine.Implementation.ProtonReceiver:</div>
<div class="dyncontent">
 <div class="center">
  <img src="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonReceiver.png" usemap="#Apache.Qpid.Proton.Engine.Implementation.ProtonReceiver_map" alt=""/>
  <map id="Apache.Qpid.Proton.Engine.Implementation.ProtonReceiver_map" name="Apache.Qpid.Proton.Engine.Implementation.ProtonReceiver_map">
<area href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink.html" alt="Apache.Qpid.Proton.Engine.Implementation.ProtonLink&lt; IReceiver &gt;" shape="rect" coords="0,112,399,136"/>
<area href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IReceiver.html" title="AMQP Receiver link resource." alt="Apache.Qpid.Proton.Engine.IReceiver" shape="rect" coords="409,112,808,136"/>
<area href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html" title="Base API for all AMQP Sender and Receiver links." alt="Apache.Qpid.Proton.Engine.ILink&lt; T &gt;" shape="rect" coords="409,56,808,80"/>
<area href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint.html" title="Represents an AMQP Connection which is owned by a single engine instance" alt="Apache.Qpid.Proton.Engine.IEndpoint&lt; T &gt;" shape="rect" coords="409,0,808,24"/>
  </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:a63b787961b93acd5795ea3cae0cd1f66"><td class="memItemLeft" align="right" valign="top"><a id="a63b787961b93acd5795ea3cae0cd1f66"></a>
&#160;</td><td class="memItemRight" valign="bottom"><b>ProtonReceiver</b> (<a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonSession.html">ProtonSession</a> session, string name, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLinkCreditState.html">ProtonLinkCreditState</a> creditState)</td></tr>
<tr class="separator:a63b787961b93acd5795ea3cae0cd1f66"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:afd2b1038cd2cc3c5426fe7738df3d870"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IReceiver.html">IReceiver</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonReceiver.html#afd2b1038cd2cc3c5426fe7738df3d870">AddCredit</a> (uint amount)</td></tr>
<tr class="memdesc:afd2b1038cd2cc3c5426fe7738df3d870"><td class="mdescLeft">&#160;</td><td class="mdescRight">Adds the given amount of credit to the receiver's already existing credit if any.  <a href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonReceiver.html#afd2b1038cd2cc3c5426fe7738df3d870">More...</a><br /></td></tr>
<tr class="separator:afd2b1038cd2cc3c5426fe7738df3d870"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a07b956348a12e0895242ba5967d08686"><td class="memItemLeft" align="right" valign="top">bool&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonReceiver.html#a07b956348a12e0895242ba5967d08686">Drain</a> ()</td></tr>
<tr class="memdesc:a07b956348a12e0895242ba5967d08686"><td class="mdescLeft">&#160;</td><td class="mdescRight">Initiate a drain of all remaining credit of this link, the remote sender will then either send enough deliveries to fulfill the drain request or report that it cannot and all remaining link credit will be consumed.  <a href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonReceiver.html#a07b956348a12e0895242ba5967d08686">More...</a><br /></td></tr>
<tr class="separator:a07b956348a12e0895242ba5967d08686"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a10b96f5bb244d557259e1f386efe3a8b"><td class="memItemLeft" align="right" valign="top">bool&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonReceiver.html#a10b96f5bb244d557259e1f386efe3a8b">Drain</a> (uint credits)</td></tr>
<tr class="memdesc:a10b96f5bb244d557259e1f386efe3a8b"><td class="mdescLeft">&#160;</td><td class="mdescRight">Initiate a drain of the given credit from this this receiver} link. If the credit given is greater than the current link credit the current credit is increased, however if the amount of credit given is less that the current amount of link credit an exception is thrown.  <a href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonReceiver.html#a10b96f5bb244d557259e1f386efe3a8b">More...</a><br /></td></tr>
<tr class="separator:a10b96f5bb244d557259e1f386efe3a8b"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:aef05837acc51245b03615bd564e41ef4"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IReceiver.html">IReceiver</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonReceiver.html#aef05837acc51245b03615bd564e41ef4">Settle</a> (Predicate&lt; <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IIncomingDelivery.html">IIncomingDelivery</a> &gt; filter)</td></tr>
<tr class="memdesc:aef05837acc51245b03615bd564e41ef4"><td class="mdescLeft">&#160;</td><td class="mdescRight">For each unsettled outgoing delivery that is pending in the receiver apply the given predicate and if it matches then settle the delivery.  <a href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonReceiver.html#aef05837acc51245b03615bd564e41ef4">More...</a><br /></td></tr>
<tr class="separator:aef05837acc51245b03615bd564e41ef4"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a8c77886875b54e44e0863ae390cc9d8d"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IReceiver.html">IReceiver</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonReceiver.html#a8c77886875b54e44e0863ae390cc9d8d">Disposition</a> (Predicate&lt; <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IIncomingDelivery.html">IIncomingDelivery</a> &gt; filter, <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Types_1_1Transport_1_1IDeliveryState.html">IDeliveryState</a> state, bool settle)</td></tr>
<tr class="memdesc:a8c77886875b54e44e0863ae390cc9d8d"><td class="mdescLeft">&#160;</td><td class="mdescRight">For each unsettled outgoing delivery that is pending in the receiver apply the given predicate and if it matches then apply the given delivery state and settled value to it.  <a href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonReceiver.html#a8c77886875b54e44e0863ae390cc9d8d">More...</a><br /></td></tr>
<tr class="separator:a8c77886875b54e44e0863ae390cc9d8d"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a820772be05bf9877909a4ba54c17f128"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IReceiver.html">IReceiver</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonReceiver.html#a820772be05bf9877909a4ba54c17f128">DeliveryAbortedHandler</a> (Action&lt; <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IIncomingDelivery.html">IIncomingDelivery</a> &gt; handler)</td></tr>
<tr class="memdesc:a820772be05bf9877909a4ba54c17f128"><td class="mdescLeft">&#160;</td><td class="mdescRight">Handler for aborted deliveries that is called for each aborted in-progress delivery. This handler is an optional convenience handler that supplements the standard delivery read event handler in cases where the users wishes to break out the processing of inbound delivery data from abort processing. If this handler is not set the receiver will call the registered delivery read handler if one is set.  <a href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonReceiver.html#a820772be05bf9877909a4ba54c17f128">More...</a><br /></td></tr>
<tr class="separator:a820772be05bf9877909a4ba54c17f128"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a8506f35ff2f3b12ba03cad38278996b8"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IReceiver.html">IReceiver</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonReceiver.html#a8506f35ff2f3b12ba03cad38278996b8">DeliveryReadHandler</a> (Action&lt; <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IIncomingDelivery.html">IIncomingDelivery</a> &gt; handler)</td></tr>
<tr class="memdesc:a8506f35ff2f3b12ba03cad38278996b8"><td class="mdescLeft">&#160;</td><td class="mdescRight">Handler for incoming deliveries that is called for each incoming transfer frame that comprises either one complete delivery or a chunk of a split framed transfer. The handler should check that the delivery being read is partial or not and act accordingly, as partial deliveries expect additional updates as more frames comprising that delivery arrive or the remote aborts the transfer.  <a href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonReceiver.html#a8506f35ff2f3b12ba03cad38278996b8">More...</a><br /></td></tr>
<tr class="separator:a8506f35ff2f3b12ba03cad38278996b8"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a4a39b81054c684e6e57a1bafb84f6b58"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IReceiver.html">IReceiver</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonReceiver.html#a4a39b81054c684e6e57a1bafb84f6b58">DeliveryStateUpdatedHandler</a> (Action&lt; <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IIncomingDelivery.html">IIncomingDelivery</a> &gt; handler)</td></tr>
<tr class="memdesc:a4a39b81054c684e6e57a1bafb84f6b58"><td class="mdescLeft">&#160;</td><td class="mdescRight">Handler for updates to the remote state of incoming deliveries that have previously been received. Remote state updates for an previously received delivery can happen when the remote settles a complete delivery or otherwise modifies the delivery outcome and the user needs to act on those changes such as a spontaneous update to the delivery state.  <a href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonReceiver.html#a4a39b81054c684e6e57a1bafb84f6b58">More...</a><br /></td></tr>
<tr class="separator:a4a39b81054c684e6e57a1bafb84f6b58"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="inherit_header pub_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink')"><img src="closed.png" alt="-"/>&#160;Public Member Functions inherited from <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink.html">Apache.Qpid.Proton.Engine.Implementation.ProtonLink&lt; IReceiver &gt;</a></td></tr>
<tr class="memitem:a1180d23f941a04c30026ae181906eca0 inherit pub_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top">override T&#160;</td><td class="memItemRight" valign="bottom"><b>Open</b> ()</td></tr>
<tr class="memdesc:a1180d23f941a04c30026ae181906eca0 inherit pub_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Open the end point locally, sending the Open performative immediately if possible or holding it until SASL negotiations or the AMQP header exchange and other required performative exchanges has completed. The endpoint will signal any registered handler of the remote opening the endpoint once the remote performative that signals open completion arrives.  <a href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink.html#a1180d23f941a04c30026ae181906eca0">More...</a><br /></td></tr>
<tr class="separator:a1180d23f941a04c30026ae181906eca0 inherit pub_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a946abb3dc6ee5e9cbfff696c186188cc inherit pub_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top">T&#160;</td><td class="memItemRight" valign="bottom"><b>Detach</b> ()</td></tr>
<tr class="memdesc:a946abb3dc6ee5e9cbfff696c186188cc inherit pub_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Detaches the local end of the link if not already closed or detached.  <a href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink.html#a946abb3dc6ee5e9cbfff696c186188cc">More...</a><br /></td></tr>
<tr class="separator:a946abb3dc6ee5e9cbfff696c186188cc inherit pub_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a8bfab840f0bb1b21461d10687d1cae35 inherit pub_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top">override T&#160;</td><td class="memItemRight" valign="bottom"><b>Close</b> ()</td></tr>
<tr class="memdesc:a8bfab840f0bb1b21461d10687d1cae35 inherit pub_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Close the end point locally and send the closing performative immediately if possible or holds it until the Connection / Engine state allows it. If the engine encounters an error writing the performative or the engine is in a failed state from a previous error then this method will throw an exception. If the engine has been shutdown then this method will close out the local end of the endpoint and clean up any local resources before returning normally.  <a href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink.html#a8bfab840f0bb1b21461d10687d1cae35">More...</a><br /></td></tr>
<tr class="separator:a8bfab840f0bb1b21461d10687d1cae35 inherit pub_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ac6e88b8f660639fab61d74d131a3d539 inherit pub_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top">T&#160;</td><td class="memItemRight" valign="bottom"><b>DetachHandler</b> (Action&lt; T &gt; handler)</td></tr>
<tr class="memdesc:ac6e88b8f660639fab61d74d131a3d539 inherit pub_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Sets a EventHandler for when an AMQP detach frame is received from the remote peer. This is a convenience event that supplements the normal link closed event point if set. If no detached event handler is set the endpoint will route the detached event to the closed event handler if set and allow it to process the event in one location.  <a href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink.html#ac6e88b8f660639fab61d74d131a3d539">More...</a><br /></td></tr>
<tr class="separator:ac6e88b8f660639fab61d74d131a3d539 inherit pub_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a0a9eda59e6ecf4b490cbc01780568297 inherit pub_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top">T&#160;</td><td class="memItemRight" valign="bottom"><b>LocalDetachHandler</b> (Action&lt; T &gt; handler)</td></tr>
<tr class="memdesc:a0a9eda59e6ecf4b490cbc01780568297 inherit pub_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Sets a Action for when an this endpoint is closed locally via a call to Close. This is a convenience event that supplements the normal locally closed event point if set. If no local detached event handler is set the endpoint will route the detached event to the local closed event handler if set and allow it to process the event in one location. Typically used by clients for logging or other state update event processing. Clients should not perform any blocking calls within this context. It is an error for the handler to throw an exception and the outcome of doing so is undefined.  <a href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink.html#a0a9eda59e6ecf4b490cbc01780568297">More...</a><br /></td></tr>
<tr class="separator:a0a9eda59e6ecf4b490cbc01780568297 inherit pub_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a61a517bb4e68e7ec13d60309d138b314 inherit pub_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top">T&#160;</td><td class="memItemRight" valign="bottom"><b>ParentEndpointClosedHandler</b> (Action&lt; T &gt; handler)</td></tr>
<tr class="memdesc:a61a517bb4e68e7ec13d60309d138b314 inherit pub_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Sets a Action delegate for when the parent Session or Connection of this link is locally closed. Typically used by clients for logging or other state update event processing. Clients should not perform any blocking calls within this context. It is an error for the handler to throw an exception and the outcome of doing so is undefined.  <a href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink.html#a61a517bb4e68e7ec13d60309d138b314">More...</a><br /></td></tr>
<tr class="separator:a61a517bb4e68e7ec13d60309d138b314 inherit pub_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:abb3c18402556dce8d120dfe0e76dca68 inherit pub_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top">T&#160;</td><td class="memItemRight" valign="bottom"><b>CreditStateUpdateHandler</b> (Action&lt; T &gt; handler)</td></tr>
<tr class="memdesc:abb3c18402556dce8d120dfe0e76dca68 inherit pub_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Handler for link credit updates that occur after a remote flow frame arrives.  <a href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink.html#abb3c18402556dce8d120dfe0e76dca68">More...</a><br /></td></tr>
<tr class="separator:abb3c18402556dce8d120dfe0e76dca68 inherit pub_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="inherit_header pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink')"><img src="closed.png" alt="-"/>&#160;Public Member Functions inherited from <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html">Apache.Qpid.Proton.Engine.ILink&lt; T &gt;</a></td></tr>
<tr class="memitem:a3faac9c1ade8fb5ba50fc9e70eefb732 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memItemLeft" align="right" valign="top">T&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#a3faac9c1ade8fb5ba50fc9e70eefb732">Detach</a> ()</td></tr>
<tr class="memdesc:a3faac9c1ade8fb5ba50fc9e70eefb732 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Detaches the local end of the link if not already closed or detached.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#a3faac9c1ade8fb5ba50fc9e70eefb732">More...</a><br /></td></tr>
<tr class="separator:a3faac9c1ade8fb5ba50fc9e70eefb732 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ada0a643f127fa197c4f4b1bc7db411df inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memItemLeft" align="right" valign="top">T&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#ada0a643f127fa197c4f4b1bc7db411df">LocalDetachHandler</a> (Action&lt; T &gt; localDetachHandler)</td></tr>
<tr class="memdesc:ada0a643f127fa197c4f4b1bc7db411df inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Sets a Action for when an this endpoint is closed locally via a call to Close. This is a convenience event that supplements the normal locally closed event point if set. If no local detached event handler is set the endpoint will route the detached event to the local closed event handler if set and allow it to process the event in one location. Typically used by clients for logging or other state update event processing. Clients should not perform any blocking calls within this context. It is an error for the handler to throw an exception and the outcome of doing so is undefined.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#ada0a643f127fa197c4f4b1bc7db411df">More...</a><br /></td></tr>
<tr class="separator:ada0a643f127fa197c4f4b1bc7db411df inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a40018e2b958e2e23bdc1a424f19f2e22 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memItemLeft" align="right" valign="top">T&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#a40018e2b958e2e23bdc1a424f19f2e22">DetachHandler</a> (Action&lt; T &gt; detachHandler)</td></tr>
<tr class="memdesc:a40018e2b958e2e23bdc1a424f19f2e22 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Sets a EventHandler for when an AMQP detach frame is received from the remote peer. This is a convenience event that supplements the normal link closed event point if set. If no detached event handler is set the endpoint will route the detached event to the closed event handler if set and allow it to process the event in one location.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#a40018e2b958e2e23bdc1a424f19f2e22">More...</a><br /></td></tr>
<tr class="separator:a40018e2b958e2e23bdc1a424f19f2e22 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:af1b533eeb6a1af97d18faed97c646c91 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memItemLeft" align="right" valign="top">T&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#af1b533eeb6a1af97d18faed97c646c91">CreditStateUpdateHandler</a> (Action&lt; T &gt; handler)</td></tr>
<tr class="memdesc:af1b533eeb6a1af97d18faed97c646c91 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Handler for link credit updates that occur after a remote flow frame arrives.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#af1b533eeb6a1af97d18faed97c646c91">More...</a><br /></td></tr>
<tr class="separator:af1b533eeb6a1af97d18faed97c646c91 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:adc2fba593c8fa5f137d069c63c4275f7 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memItemLeft" align="right" valign="top">T&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#adc2fba593c8fa5f137d069c63c4275f7">ParentEndpointClosedHandler</a> (Action&lt; T &gt; handler)</td></tr>
<tr class="memdesc:adc2fba593c8fa5f137d069c63c4275f7 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Sets a Action delegate for when the parent Session or Connection of this link is locally closed. Typically used by clients for logging or other state update event processing. Clients should not perform any blocking calls within this context. It is an error for the handler to throw an exception and the outcome of doing so is undefined.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#adc2fba593c8fa5f137d069c63c4275f7">More...</a><br /></td></tr>
<tr class="separator:adc2fba593c8fa5f137d069c63c4275f7 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="inherit_header pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint')"><img src="closed.png" alt="-"/>&#160;Public Member Functions inherited from <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint.html">Apache.Qpid.Proton.Engine.IEndpoint&lt; T &gt;</a></td></tr>
<tr class="memitem:ae4e9579365862c944a0cd79fa218d183 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="memItemLeft" align="right" valign="top">T&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint.html#ae4e9579365862c944a0cd79fa218d183">Open</a> ()</td></tr>
<tr class="memdesc:ae4e9579365862c944a0cd79fa218d183 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="mdescLeft">&#160;</td><td class="mdescRight">Open the end point locally, sending the Open performative immediately if possible or holding it until SASL negotiations or the AMQP header exchange and other required performative exchanges has completed. The endpoint will signal any registered handler of the remote opening the endpoint once the remote performative that signals open completion arrives.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint.html#ae4e9579365862c944a0cd79fa218d183">More...</a><br /></td></tr>
<tr class="separator:ae4e9579365862c944a0cd79fa218d183 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a15b7acdd0d22c2ade430a336a7678a41 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="memItemLeft" align="right" valign="top">T&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint.html#a15b7acdd0d22c2ade430a336a7678a41">Close</a> ()</td></tr>
<tr class="memdesc:a15b7acdd0d22c2ade430a336a7678a41 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="mdescLeft">&#160;</td><td class="mdescRight">Close the end point locally and send the closing performative immediately if possible or holds it until the Connection / <a class="el" href="namespaceApache_1_1Qpid_1_1Proton_1_1Engine.html">Engine</a> state allows it. If the engine encounters an error writing the performative or the engine is in a failed state from a previous error then this method will throw an exception. If the engine has been shutdown then this method will close out the local end of the endpoint and clean up any local resources before returning normally.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint.html#a15b7acdd0d22c2ade430a336a7678a41">More...</a><br /></td></tr>
<tr class="separator:a15b7acdd0d22c2ade430a336a7678a41 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a036cf0b0c5d588a086e24699a0a52b59 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="memItemLeft" align="right" valign="top">T&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint.html#a036cf0b0c5d588a086e24699a0a52b59">LocalOpenHandler</a> (Action&lt; T &gt; localOpenHandler)</td></tr>
<tr class="memdesc:a036cf0b0c5d588a086e24699a0a52b59 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="mdescLeft">&#160;</td><td class="mdescRight">Sets a Action for when an this endpoint is opened locally via a call to Open. Typically used by clients for logging or other state update event processing. Clients should not perform any blocking calls within this context. It is an error for the handler to throw an exception and the outcome of doing so is undefined. Typically used by clients as servers will typically listen to some parent resource event handler to determine if the remote is initiating a resource open.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint.html#a036cf0b0c5d588a086e24699a0a52b59">More...</a><br /></td></tr>
<tr class="separator:a036cf0b0c5d588a086e24699a0a52b59 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a0f769d3342763f21fb9a5bcd62ab0aee inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="memItemLeft" align="right" valign="top">T&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint.html#a0f769d3342763f21fb9a5bcd62ab0aee">LocalCloseHandler</a> (Action&lt; T &gt; localCloseHandler)</td></tr>
<tr class="memdesc:a0f769d3342763f21fb9a5bcd62ab0aee inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="mdescLeft">&#160;</td><td class="mdescRight">Sets a Action for when an this endpoint is closed locally via a call to Close. Typically used by clients for logging or other state update event processing. Clients should not perform any blocking calls within this context. It is an error for the handler to throw an exception and the outcome of doing so is undefined.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint.html#a0f769d3342763f21fb9a5bcd62ab0aee">More...</a><br /></td></tr>
<tr class="separator:a0f769d3342763f21fb9a5bcd62ab0aee inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a007ae977fc124ddc836f315d018ab05d inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="memItemLeft" align="right" valign="top">T&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint.html#a007ae977fc124ddc836f315d018ab05d">OpenHandler</a> (Action&lt; T &gt; localOpenHandler)</td></tr>
<tr class="memdesc:a007ae977fc124ddc836f315d018ab05d inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="mdescLeft">&#160;</td><td class="mdescRight">Sets a Action for when an AMQP Open frame is received from the remote peer. Used to process remotely initiated Connections. Locally initiated sessions have their own Action invoked instead. This method is typically used by servers to listen for the remote peer to open its endpoint, while a client would listen for the server to open its end of the endpoint once a local open has been performed. Typically used by clients as servers will typically listen to some parent resource event handler to determine if the remote is initiating a resource open.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint.html#a007ae977fc124ddc836f315d018ab05d">More...</a><br /></td></tr>
<tr class="separator:a007ae977fc124ddc836f315d018ab05d inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a9a36c96c71b9b677340dcb5476146c82 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="memItemLeft" align="right" valign="top">T&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint.html#a9a36c96c71b9b677340dcb5476146c82">CloseHandler</a> (Action&lt; T &gt; localCloseHandler)</td></tr>
<tr class="memdesc:a9a36c96c71b9b677340dcb5476146c82 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="mdescLeft">&#160;</td><td class="mdescRight">Sets a EventHandler for when an AMQP closing frame is received from the remote peer.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint.html#a9a36c96c71b9b677340dcb5476146c82">More...</a><br /></td></tr>
<tr class="separator:a9a36c96c71b9b677340dcb5476146c82 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ad985e08f80b4efc7d4e9ec236c3b3612 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="memItemLeft" align="right" valign="top">T&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint.html#ad985e08f80b4efc7d4e9ec236c3b3612">EngineShutdownHandler</a> (Action&lt; <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEngine.html">IEngine</a> &gt; shutdownHandler)</td></tr>
<tr class="memdesc:ad985e08f80b4efc7d4e9ec236c3b3612 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="mdescLeft">&#160;</td><td class="mdescRight">Sets an Action that is invoked when the engine that supports this endpoint is shutdown which indicates a desire to terminate all engine operations. Any endpoint that has been both locally and remotely closed will not receive this event as it will no longer be tracked by the parent its parent endpoint. A typical use of this event would be from a locally closed endpoint that is awaiting response from the remote. If this event fires then there will never be a remote response to any pending operations and the client or server instance should react accordingly to clean up any related resources etc.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint.html#ad985e08f80b4efc7d4e9ec236c3b3612">More...</a><br /></td></tr>
<tr class="separator:ad985e08f80b4efc7d4e9ec236c3b3612 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="memSeparator" colspan="2">&#160;</td></tr>
</table><table class="memberdecls">
<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pro-methods"></a>
Protected Member Functions</h2></td></tr>
<tr class="memitem:a242b573f137479cd8079c8985f8f97e7"><td class="memItemLeft" align="right" valign="top"><a id="a242b573f137479cd8079c8985f8f97e7"></a>
override void&#160;</td><td class="memItemRight" valign="bottom"><b>HandleRemoteAttach</b> (<a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Types_1_1Transport_1_1Attach.html">Attach</a> attach)</td></tr>
<tr class="separator:a242b573f137479cd8079c8985f8f97e7"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a2f6b7392576ede85f8a9300c126e771c"><td class="memItemLeft" align="right" valign="top"><a id="a2f6b7392576ede85f8a9300c126e771c"></a>
override void&#160;</td><td class="memItemRight" valign="bottom"><b>HandleRemoteDetach</b> (<a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Types_1_1Transport_1_1Detach.html">Detach</a> detach)</td></tr>
<tr class="separator:a2f6b7392576ede85f8a9300c126e771c"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:aa1e0413d48226f4cd7561b6e3a8aca35"><td class="memItemLeft" align="right" valign="top"><a id="aa1e0413d48226f4cd7561b6e3a8aca35"></a>
override void&#160;</td><td class="memItemRight" valign="bottom"><b>HandleRemoteFlow</b> (<a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Types_1_1Transport_1_1Flow.html">Flow</a> flow)</td></tr>
<tr class="separator:aa1e0413d48226f4cd7561b6e3a8aca35"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a7a68db7f42faf22328e9a1d0e11af8d0"><td class="memItemLeft" align="right" valign="top"><a id="a7a68db7f42faf22328e9a1d0e11af8d0"></a>
override void&#160;</td><td class="memItemRight" valign="bottom"><b>HandleRemoteDisposition</b> (<a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Types_1_1Transport_1_1Disposition.html">Disposition</a> disposition, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonOutgoingDelivery.html">ProtonOutgoingDelivery</a> delivery)</td></tr>
<tr class="separator:a7a68db7f42faf22328e9a1d0e11af8d0"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a0379191489f4dc8ef90ac4ff2f555723"><td class="memItemLeft" align="right" valign="top"><a id="a0379191489f4dc8ef90ac4ff2f555723"></a>
override void&#160;</td><td class="memItemRight" valign="bottom"><b>HandleRemoteDisposition</b> (<a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Types_1_1Transport_1_1Disposition.html">Disposition</a> disposition, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonIncomingDelivery.html">ProtonIncomingDelivery</a> delivery)</td></tr>
<tr class="separator:a0379191489f4dc8ef90ac4ff2f555723"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a49a54e51a6e69f5359a55bda1d33b7f7"><td class="memItemLeft" align="right" valign="top"><a id="a49a54e51a6e69f5359a55bda1d33b7f7"></a>
override void&#160;</td><td class="memItemRight" valign="bottom"><b>HandleRemoteTransfer</b> (<a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Types_1_1Transport_1_1Transfer.html">Transfer</a> transfer, <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a> payload, out <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonIncomingDelivery.html">ProtonIncomingDelivery</a> delivery)</td></tr>
<tr class="separator:a49a54e51a6e69f5359a55bda1d33b7f7"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ae1e1a9761c1e92199629a59d69df15cb"><td class="memItemLeft" align="right" valign="top"><a id="ae1e1a9761c1e92199629a59d69df15cb"></a>
override void&#160;</td><td class="memItemRight" valign="bottom"><b>HandleDecorateOfOutgoingFlow</b> (<a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Types_1_1Transport_1_1Flow.html">Flow</a> flow)</td></tr>
<tr class="separator:ae1e1a9761c1e92199629a59d69df15cb"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:afe2c7ea946e79a0a179d1252a03d3313"><td class="memItemLeft" align="right" valign="top"><a id="afe2c7ea946e79a0a179d1252a03d3313"></a>
override void&#160;</td><td class="memItemRight" valign="bottom"><b>HandleSessionCreditStateUpdates</b> (in <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonSessionOutgoingWindow.html">ProtonSessionOutgoingWindow</a> window)</td></tr>
<tr class="separator:afe2c7ea946e79a0a179d1252a03d3313"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:abdd8a85c4f7af8a6b505855d7e9f8757"><td class="memItemLeft" align="right" valign="top"><a id="abdd8a85c4f7af8a6b505855d7e9f8757"></a>
override void&#160;</td><td class="memItemRight" valign="bottom"><b>HandleSessionCreditStateUpdates</b> (in <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonSessionIncomingWindow.html">ProtonSessionIncomingWindow</a> window)</td></tr>
<tr class="separator:abdd8a85c4f7af8a6b505855d7e9f8757"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="inherit_header pro_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td colspan="2" onclick="javascript:toggleInherit('pro_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink')"><img src="closed.png" alt="-"/>&#160;Protected Member Functions inherited from <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink.html">Apache.Qpid.Proton.Engine.Implementation.ProtonLink&lt; IReceiver &gt;</a></td></tr>
<tr class="memitem:a372ad059e5db219eb8e52a010dade689 inherit pro_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="a372ad059e5db219eb8e52a010dade689"></a>
&#160;</td><td class="memItemRight" valign="bottom"><b>ProtonLink</b> (<a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonSession.html">ProtonSession</a> session, string name, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLinkCreditState.html">ProtonLinkCreditState</a> creditState)</td></tr>
<tr class="separator:a372ad059e5db219eb8e52a010dade689 inherit pro_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:afd4070cf4bb3b3858395d3379945bc0d inherit pro_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="afd4070cf4bb3b3858395d3379945bc0d"></a>
abstract void&#160;</td><td class="memItemRight" valign="bottom"><b>HandleRemoteAttach</b> (<a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Types_1_1Transport_1_1Attach.html">Attach</a> attach)</td></tr>
<tr class="separator:afd4070cf4bb3b3858395d3379945bc0d inherit pro_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a85a074ca76b77e0405152ea1b2067426 inherit pro_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="a85a074ca76b77e0405152ea1b2067426"></a>
abstract void&#160;</td><td class="memItemRight" valign="bottom"><b>HandleRemoteDetach</b> (<a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Types_1_1Transport_1_1Detach.html">Detach</a> detach)</td></tr>
<tr class="separator:a85a074ca76b77e0405152ea1b2067426 inherit pro_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a1b0ff1d0fe8216cb2d1229763c696fae inherit pro_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="a1b0ff1d0fe8216cb2d1229763c696fae"></a>
abstract void&#160;</td><td class="memItemRight" valign="bottom"><b>HandleRemoteFlow</b> (<a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Types_1_1Transport_1_1Flow.html">Flow</a> flow)</td></tr>
<tr class="separator:a1b0ff1d0fe8216cb2d1229763c696fae inherit pro_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a69451f6cfaeefb0a327cd51a09d3c04a inherit pro_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="a69451f6cfaeefb0a327cd51a09d3c04a"></a>
abstract void&#160;</td><td class="memItemRight" valign="bottom"><b>HandleRemoteDisposition</b> (<a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Types_1_1Transport_1_1Disposition.html">Disposition</a> disposition, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonOutgoingDelivery.html">ProtonOutgoingDelivery</a> delivery)</td></tr>
<tr class="separator:a69451f6cfaeefb0a327cd51a09d3c04a inherit pro_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a505856cbb41aae2386fc82911457a9f6 inherit pro_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="a505856cbb41aae2386fc82911457a9f6"></a>
abstract void&#160;</td><td class="memItemRight" valign="bottom"><b>HandleRemoteDisposition</b> (<a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Types_1_1Transport_1_1Disposition.html">Disposition</a> disposition, <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonIncomingDelivery.html">ProtonIncomingDelivery</a> delivery)</td></tr>
<tr class="separator:a505856cbb41aae2386fc82911457a9f6 inherit pro_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ad6065d8be133b5f9ac4361019b6b35e7 inherit pro_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="ad6065d8be133b5f9ac4361019b6b35e7"></a>
abstract void&#160;</td><td class="memItemRight" valign="bottom"><b>HandleRemoteTransfer</b> (<a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Types_1_1Transport_1_1Transfer.html">Transfer</a> transfer, <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Buffer_1_1IProtonBuffer.html">IProtonBuffer</a> payload, out <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonIncomingDelivery.html">ProtonIncomingDelivery</a> delivery)</td></tr>
<tr class="separator:ad6065d8be133b5f9ac4361019b6b35e7 inherit pro_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ae3e2ca1a875b9de8920034d5e2dbc622 inherit pro_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="ae3e2ca1a875b9de8920034d5e2dbc622"></a>
abstract void&#160;</td><td class="memItemRight" valign="bottom"><b>HandleDecorateOfOutgoingFlow</b> (<a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Types_1_1Transport_1_1Flow.html">Flow</a> flow)</td></tr>
<tr class="separator:ae3e2ca1a875b9de8920034d5e2dbc622 inherit pro_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a55cf6d5b93a5200ebbdc9cb89f25c340 inherit pro_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="a55cf6d5b93a5200ebbdc9cb89f25c340"></a>
virtual void&#160;</td><td class="memItemRight" valign="bottom"><b>TransitionedToLocallyOpened</b> ()</td></tr>
<tr class="separator:a55cf6d5b93a5200ebbdc9cb89f25c340 inherit pro_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a6c819735156be7a00ac58c2f6aa95969 inherit pro_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="a6c819735156be7a00ac58c2f6aa95969"></a>
virtual void&#160;</td><td class="memItemRight" valign="bottom"><b>TransitionedToLocallyDetached</b> ()</td></tr>
<tr class="separator:a6c819735156be7a00ac58c2f6aa95969 inherit pro_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ac76dc26a5e1787aacbb7334f316ab702 inherit pro_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="ac76dc26a5e1787aacbb7334f316ab702"></a>
virtual void&#160;</td><td class="memItemRight" valign="bottom"><b>TransitionedToLocallyClosed</b> ()</td></tr>
<tr class="separator:ac76dc26a5e1787aacbb7334f316ab702 inherit pro_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a725d7f2a0a4e52122263df0643239cc2 inherit pro_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="a725d7f2a0a4e52122263df0643239cc2"></a>
virtual void&#160;</td><td class="memItemRight" valign="bottom"><b>TransitionToRemotelyOpenedState</b> ()</td></tr>
<tr class="separator:a725d7f2a0a4e52122263df0643239cc2 inherit pro_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:aa6795353bb74533c76301e1bb762d045 inherit pro_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="aa6795353bb74533c76301e1bb762d045"></a>
virtual void&#160;</td><td class="memItemRight" valign="bottom"><b>TransitionToRemotelyDetached</b> ()</td></tr>
<tr class="separator:aa6795353bb74533c76301e1bb762d045 inherit pro_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ad997d8b782ae5270382a12e71f33cb7b inherit pro_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="ad997d8b782ae5270382a12e71f33cb7b"></a>
virtual void&#160;</td><td class="memItemRight" valign="bottom"><b>TransitionToRemotelyClosed</b> ()</td></tr>
<tr class="separator:ad997d8b782ae5270382a12e71f33cb7b inherit pro_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a94303acd2fbb805e627754a36304d0f1 inherit pro_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="a94303acd2fbb805e627754a36304d0f1"></a>
virtual void&#160;</td><td class="memItemRight" valign="bottom"><b>TransitionToParentLocallyClosed</b> ()</td></tr>
<tr class="separator:a94303acd2fbb805e627754a36304d0f1 inherit pro_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a4a096d4de9898f67959697be6e43d32e inherit pro_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="a4a096d4de9898f67959697be6e43d32e"></a>
virtual void&#160;</td><td class="memItemRight" valign="bottom"><b>TransitionToParentRemotelyClosed</b> ()</td></tr>
<tr class="separator:a4a096d4de9898f67959697be6e43d32e inherit pro_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:acb7bf9be4299568c889cc2b040517c86 inherit pro_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="acb7bf9be4299568c889cc2b040517c86"></a>
void&#160;</td><td class="memItemRight" valign="bottom"><b>CheckLinkOperable</b> (string failurePrefix)</td></tr>
<tr class="separator:acb7bf9be4299568c889cc2b040517c86 inherit pro_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a0175fc85d9bd0ec33d7dde93815d32de inherit pro_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="a0175fc85d9bd0ec33d7dde93815d32de"></a>
bool&#160;</td><td class="memItemRight" valign="bottom"><b>AreDeliveriesStillActive</b> ()</td></tr>
<tr class="separator:a0175fc85d9bd0ec33d7dde93815d32de inherit pro_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ab7cabb133f0b82ced137d06b86c69e26 inherit pro_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="ab7cabb133f0b82ced137d06b86c69e26"></a>
void&#160;</td><td class="memItemRight" valign="bottom"><b>CheckNotOpened</b> (string errorMessage)</td></tr>
<tr class="separator:ab7cabb133f0b82ced137d06b86c69e26 inherit pro_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a0c61a0430f257d0f9994de7f050403cf inherit pro_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="a0c61a0430f257d0f9994de7f050403cf"></a>
void&#160;</td><td class="memItemRight" valign="bottom"><b>CheckNotClosed</b> (string errorMessage)</td></tr>
<tr class="separator:a0c61a0430f257d0f9994de7f050403cf inherit pro_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a32e9f93ce2ed914ce2d6a27b23b06e56 inherit pro_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="a32e9f93ce2ed914ce2d6a27b23b06e56"></a>
void&#160;</td><td class="memItemRight" valign="bottom"><b>TrySyncLocalStateWithRemote</b> ()</td></tr>
<tr class="separator:a32e9f93ce2ed914ce2d6a27b23b06e56 inherit pro_methods_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><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:a94ad712dec2795ffe3ddff223fcabfca"><td class="memItemLeft" align="right" valign="top"><a id="a94ad712dec2795ffe3ddff223fcabfca"></a>
override uint&#160;</td><td class="memItemRight" valign="bottom"><b>Credit</b><code> [get]</code></td></tr>
<tr class="separator:a94ad712dec2795ffe3ddff223fcabfca"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:af09b88b5063d2516414abbaa7e5c4e9e"><td class="memItemLeft" align="right" valign="top"><a id="af09b88b5063d2516414abbaa7e5c4e9e"></a>
override bool&#160;</td><td class="memItemRight" valign="bottom"><b>IsDraining</b><code> [get]</code></td></tr>
<tr class="separator:af09b88b5063d2516414abbaa7e5c4e9e"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a9f60863b0d19fe5a571c46e03723e244"><td class="memItemLeft" align="right" valign="top"><a id="a9f60863b0d19fe5a571c46e03723e244"></a>
override <a class="el" href="namespaceApache_1_1Qpid_1_1Proton_1_1Types_1_1Transport.html#a5f514350b2297fec543826213ed83cd4">Role</a>&#160;</td><td class="memItemRight" valign="bottom"><b>Role</b><code> [get]</code></td></tr>
<tr class="separator:a9f60863b0d19fe5a571c46e03723e244"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a285ec3f6d878dbcbc83c816f3ef715ae"><td class="memItemLeft" align="right" valign="top"><a id="a285ec3f6d878dbcbc83c816f3ef715ae"></a>
<a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Types_1_1Transport_1_1IDeliveryState.html">IDeliveryState</a>&#160;</td><td class="memItemRight" valign="bottom"><b>DefaultDeliveryState</b><code> [get, set]</code></td></tr>
<tr class="separator:a285ec3f6d878dbcbc83c816f3ef715ae"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a5a17a9daa129f7b595add857015abb84"><td class="memItemLeft" align="right" valign="top"><a id="a5a17a9daa129f7b595add857015abb84"></a>
bool&#160;</td><td class="memItemRight" valign="bottom"><b>HasUnsettled</b><code> [get]</code></td></tr>
<tr class="separator:a5a17a9daa129f7b595add857015abb84"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ab6aad9d6ec8b4b1e88c26b3a85d9effb"><td class="memItemLeft" align="right" valign="top"><a id="ab6aad9d6ec8b4b1e88c26b3a85d9effb"></a>
IReadOnlyCollection&lt; <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IIncomingDelivery.html">IIncomingDelivery</a> &gt;&#160;</td><td class="memItemRight" valign="bottom"><b>Unsettled</b><code> [get]</code></td></tr>
<tr class="separator:ab6aad9d6ec8b4b1e88c26b3a85d9effb"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="inherit_header properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td colspan="2" onclick="javascript:toggleInherit('properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink')"><img src="closed.png" alt="-"/>&#160;Properties inherited from <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink.html">Apache.Qpid.Proton.Engine.Implementation.ProtonLink&lt; IReceiver &gt;</a></td></tr>
<tr class="memitem:a3a9cfa0bcd7c5f4aed30165c47cc8985 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="a3a9cfa0bcd7c5f4aed30165c47cc8985"></a>
virtual <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IConnection.html">IConnection</a>&#160;</td><td class="memItemRight" valign="bottom"><b>Connection</b><code> [get]</code></td></tr>
<tr class="separator:a3a9cfa0bcd7c5f4aed30165c47cc8985 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a503a7db6e7aa3cf8020cf4cdc8484c89 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="a503a7db6e7aa3cf8020cf4cdc8484c89"></a>
virtual <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ISession.html">ISession</a>&#160;</td><td class="memItemRight" valign="bottom"><b>Session</b><code> [get]</code></td></tr>
<tr class="separator:a503a7db6e7aa3cf8020cf4cdc8484c89 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ad26187f15b9c8d5fdc75dfee7c8d02f1 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="ad26187f15b9c8d5fdc75dfee7c8d02f1"></a>
bool&#160;</td><td class="memItemRight" valign="bottom"><b>IsSender</b><code> [get]</code></td></tr>
<tr class="separator:ad26187f15b9c8d5fdc75dfee7c8d02f1 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a0fd91c3369a0984b82137aa710fd568b inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="a0fd91c3369a0984b82137aa710fd568b"></a>
bool&#160;</td><td class="memItemRight" valign="bottom"><b>IsReceiver</b><code> [get]</code></td></tr>
<tr class="separator:a0fd91c3369a0984b82137aa710fd568b inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a7bc37de6ff7a8e8721681b4847559e12 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="a7bc37de6ff7a8e8721681b4847559e12"></a>
uint&#160;</td><td class="memItemRight" valign="bottom"><b>Handle</b><code> [get]</code></td></tr>
<tr class="separator:a7bc37de6ff7a8e8721681b4847559e12 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:afac43cd1516d3172a6c0530b75c1b3ce inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="afac43cd1516d3172a6c0530b75c1b3ce"></a>
string&#160;</td><td class="memItemRight" valign="bottom"><b>Name</b><code> [get]</code></td></tr>
<tr class="separator:afac43cd1516d3172a6c0530b75c1b3ce inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a70c9c2e719a11976f109ba948553b613 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="a70c9c2e719a11976f109ba948553b613"></a>
<a class="el" href="namespaceApache_1_1Qpid_1_1Proton_1_1Engine.html#acbdc8141247342461fc88ea23eac6ad6">LinkState</a>&#160;</td><td class="memItemRight" valign="bottom"><b>LinkState</b><code> [get]</code></td></tr>
<tr class="separator:a70c9c2e719a11976f109ba948553b613 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a2fb0be05f71aea262b59ca24efbd2ff8 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="a2fb0be05f71aea262b59ca24efbd2ff8"></a>
<a class="el" href="namespaceApache_1_1Qpid_1_1Proton_1_1Engine.html#acbdc8141247342461fc88ea23eac6ad6">LinkState</a>&#160;</td><td class="memItemRight" valign="bottom"><b>RemoteState</b><code> [get]</code></td></tr>
<tr class="separator:a2fb0be05f71aea262b59ca24efbd2ff8 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ac26d7688839eaebbde18235ff462c6a7 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="ac26d7688839eaebbde18235ff462c6a7"></a>
SenderSettleMode&#160;</td><td class="memItemRight" valign="bottom"><b>SenderSettleMode</b><code> [get, set]</code></td></tr>
<tr class="separator:ac26d7688839eaebbde18235ff462c6a7 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:aa9f7917d26509858cb304a29d9fc1fa3 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="aa9f7917d26509858cb304a29d9fc1fa3"></a>
SenderSettleMode&#160;</td><td class="memItemRight" valign="bottom"><b>RemoteSenderSettleMode</b><code> [get]</code></td></tr>
<tr class="separator:aa9f7917d26509858cb304a29d9fc1fa3 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a8013714a1f5566ca03548b647d6b64a5 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="a8013714a1f5566ca03548b647d6b64a5"></a>
ReceiverSettleMode&#160;</td><td class="memItemRight" valign="bottom"><b>ReceiverSettleMode</b><code> [get, set]</code></td></tr>
<tr class="separator:a8013714a1f5566ca03548b647d6b64a5 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a2f65f3adfdf7c1cc225c93e4eaaace04 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="a2f65f3adfdf7c1cc225c93e4eaaace04"></a>
ReceiverSettleMode&#160;</td><td class="memItemRight" valign="bottom"><b>RemoteReceiverSettleMode</b><code> [get]</code></td></tr>
<tr class="separator:a2f65f3adfdf7c1cc225c93e4eaaace04 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:aab0ffa7ac6063510308e0953bcc2c221 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="aab0ffa7ac6063510308e0953bcc2c221"></a>
<a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Types_1_1Messaging_1_1Source.html">Source</a>&#160;</td><td class="memItemRight" valign="bottom"><b>Source</b><code> [get, set]</code></td></tr>
<tr class="separator:aab0ffa7ac6063510308e0953bcc2c221 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:aae0b2bee671da7d87b3aefd4f1f2096f inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="aae0b2bee671da7d87b3aefd4f1f2096f"></a>
<a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Types_1_1Messaging_1_1Source.html">Source</a>&#160;</td><td class="memItemRight" valign="bottom"><b>RemoteSource</b><code> [get]</code></td></tr>
<tr class="separator:aae0b2bee671da7d87b3aefd4f1f2096f inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:aeb130376ccc29fc7f7e4a948d075138e inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="aeb130376ccc29fc7f7e4a948d075138e"></a>
<a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Types_1_1Messaging_1_1ITerminus.html">ITerminus</a>&#160;</td><td class="memItemRight" valign="bottom"><b>Terminus</b><code> [get, set]</code></td></tr>
<tr class="separator:aeb130376ccc29fc7f7e4a948d075138e inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a3e0b45ac3a7715052938e4a25918c66a inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="a3e0b45ac3a7715052938e4a25918c66a"></a>
<a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Types_1_1Transactions_1_1Coordinator.html">Coordinator</a>&#160;</td><td class="memItemRight" valign="bottom"><b>Coordinator</b><code> [get, set]</code></td></tr>
<tr class="separator:a3e0b45ac3a7715052938e4a25918c66a inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a9b99f354f485870658caf097560fc587 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="a9b99f354f485870658caf097560fc587"></a>
<a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Types_1_1Messaging_1_1Target.html">Target</a>&#160;</td><td class="memItemRight" valign="bottom"><b>Target</b><code> [get, set]</code></td></tr>
<tr class="separator:a9b99f354f485870658caf097560fc587 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a159882509dd646cc2ce438d66351bedb inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="a159882509dd646cc2ce438d66351bedb"></a>
<a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Types_1_1Messaging_1_1ITerminus.html">ITerminus</a>&#160;</td><td class="memItemRight" valign="bottom"><b>RemoteTerminus</b><code> [get]</code></td></tr>
<tr class="separator:a159882509dd646cc2ce438d66351bedb inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:aba69152f6fe6ac403bfa18b406e3d3f7 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="aba69152f6fe6ac403bfa18b406e3d3f7"></a>
override <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Types_1_1Symbol.html">Symbol</a>[]??&#160;</td><td class="memItemRight" valign="bottom"><b>OfferedCapabilities</b><code> [get, set]</code></td></tr>
<tr class="separator:aba69152f6fe6ac403bfa18b406e3d3f7 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ace1a30a0449bd468d98332f0e36e376d inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="ace1a30a0449bd468d98332f0e36e376d"></a>
override <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Types_1_1Symbol.html">Symbol</a>[]??&#160;</td><td class="memItemRight" valign="bottom"><b>DesiredCapabilities</b><code> [get, set]</code></td></tr>
<tr class="separator:ace1a30a0449bd468d98332f0e36e376d inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a8020a794ba96c61e731fc7e0f669e48a inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="a8020a794ba96c61e731fc7e0f669e48a"></a>
override <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Types_1_1Symbol.html">Symbol</a>[]??&#160;</td><td class="memItemRight" valign="bottom"><b>RemoteOfferedCapabilities</b><code> [get]</code></td></tr>
<tr class="separator:a8020a794ba96c61e731fc7e0f669e48a inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a4dd3657df33b5b24468b43fff4ac555b inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="a4dd3657df33b5b24468b43fff4ac555b"></a>
override <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Types_1_1Symbol.html">Symbol</a>[]??&#160;</td><td class="memItemRight" valign="bottom"><b>RemoteDesiredCapabilities</b><code> [get]</code></td></tr>
<tr class="separator:a4dd3657df33b5b24468b43fff4ac555b inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a6004be1264806430a35d34865f8c99c9 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="a6004be1264806430a35d34865f8c99c9"></a>
override IReadOnlyDictionary&lt; <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Types_1_1Symbol.html">Symbol</a>, object &gt;&#160;</td><td class="memItemRight" valign="bottom"><b>Properties</b><code> [get, set]</code></td></tr>
<tr class="separator:a6004be1264806430a35d34865f8c99c9 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:acab728c7eeb309dd27b57d9824caefa1 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="acab728c7eeb309dd27b57d9824caefa1"></a>
override IReadOnlyDictionary&lt; <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Types_1_1Symbol.html">Symbol</a>, object &gt;&#160;</td><td class="memItemRight" valign="bottom"><b>RemoteProperties</b><code> [get]</code></td></tr>
<tr class="separator:acab728c7eeb309dd27b57d9824caefa1 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:af23f6f5e2497b32f6958e5953e607824 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="af23f6f5e2497b32f6958e5953e607824"></a>
ulong&#160;</td><td class="memItemRight" valign="bottom"><b>MaxMessageSize</b><code> [get, set]</code></td></tr>
<tr class="separator:af23f6f5e2497b32f6958e5953e607824 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a176820eece6bacef02d5748e0c636585 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="a176820eece6bacef02d5748e0c636585"></a>
override bool&#160;</td><td class="memItemRight" valign="bottom"><b>IsLocallyOpen</b><code> [get]</code></td></tr>
<tr class="separator:a176820eece6bacef02d5748e0c636585 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:acde17299a7d7329100bfb9fcc9ad6d2b inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="acde17299a7d7329100bfb9fcc9ad6d2b"></a>
override bool&#160;</td><td class="memItemRight" valign="bottom"><b>IsLocallyClosed</b><code> [get]</code></td></tr>
<tr class="separator:acde17299a7d7329100bfb9fcc9ad6d2b inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:aac08663fffda68726cf1543b2c6d17fb inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="aac08663fffda68726cf1543b2c6d17fb"></a>
override bool&#160;</td><td class="memItemRight" valign="bottom"><b>IsRemotelyOpen</b><code> [get]</code></td></tr>
<tr class="separator:aac08663fffda68726cf1543b2c6d17fb inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a3c54eb3ba1d04d2a593d7c0d5a5a9b4a inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="a3c54eb3ba1d04d2a593d7c0d5a5a9b4a"></a>
override bool&#160;</td><td class="memItemRight" valign="bottom"><b>IsRemotelyClosed</b><code> [get]</code></td></tr>
<tr class="separator:a3c54eb3ba1d04d2a593d7c0d5a5a9b4a inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a3c2b8e026901c1d081866e9e2383e7f9 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="a3c2b8e026901c1d081866e9e2383e7f9"></a>
bool&#160;</td><td class="memItemRight" valign="bottom"><b>IsLocallyDetached</b><code> [get]</code></td></tr>
<tr class="separator:a3c2b8e026901c1d081866e9e2383e7f9 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:aef56666e701e823cd4fa77d113860c73 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="aef56666e701e823cd4fa77d113860c73"></a>
bool&#160;</td><td class="memItemRight" valign="bottom"><b>IsLocallyClosedOrDetached</b><code> [get]</code></td></tr>
<tr class="separator:aef56666e701e823cd4fa77d113860c73 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a623c244a534cfacef78120664f1f78d4 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="a623c244a534cfacef78120664f1f78d4"></a>
bool&#160;</td><td class="memItemRight" valign="bottom"><b>IsRemotelyDetached</b><code> [get]</code></td></tr>
<tr class="separator:a623c244a534cfacef78120664f1f78d4 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a4ae0e079f54464c91605fcf636eec1ca inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="a4ae0e079f54464c91605fcf636eec1ca"></a>
bool&#160;</td><td class="memItemRight" valign="bottom"><b>IsRemotelyClosedOrDetached</b><code> [get]</code></td></tr>
<tr class="separator:a4ae0e079f54464c91605fcf636eec1ca inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a6f6efce64aaf093a6c91b252fd199e73 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="a6f6efce64aaf093a6c91b252fd199e73"></a>
abstract uint&#160;</td><td class="memItemRight" valign="bottom"><b>Credit</b><code> [get]</code></td></tr>
<tr class="separator:a6f6efce64aaf093a6c91b252fd199e73 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a9830c03ffc4ceeb56dcbdf47fe9ebb66 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="a9830c03ffc4ceeb56dcbdf47fe9ebb66"></a>
abstract bool&#160;</td><td class="memItemRight" valign="bottom"><b>IsDraining</b><code> [get]</code></td></tr>
<tr class="separator:a9830c03ffc4ceeb56dcbdf47fe9ebb66 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:aa1a42ce3771d206a434303496bba18c3 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="aa1a42ce3771d206a434303496bba18c3"></a>
abstract <a class="el" href="namespaceApache_1_1Qpid_1_1Proton_1_1Types_1_1Transport.html#a5f514350b2297fec543826213ed83cd4">Role</a>&#160;</td><td class="memItemRight" valign="bottom"><b>Role</b><code> [get]</code></td></tr>
<tr class="separator:aa1a42ce3771d206a434303496bba18c3 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a63657123aad21a926876b3ffd4341fbf inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="a63657123aad21a926876b3ffd4341fbf"></a>
<a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLinkCreditState.html">ProtonLinkCreditState</a>&#160;</td><td class="memItemRight" valign="bottom"><b>CreditState</b><code> [get]</code></td></tr>
<tr class="separator:a63657123aad21a926876b3ffd4341fbf inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:af963bdb6a2666a5da422ad4dec8dad13 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="af963bdb6a2666a5da422ad4dec8dad13"></a>
bool&#160;</td><td class="memItemRight" valign="bottom"><b>WasLocalAttachSent</b><code> [get]</code></td></tr>
<tr class="separator:af963bdb6a2666a5da422ad4dec8dad13 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ab32bcd2fa919f7a014f923c83a7ead1a inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="ab32bcd2fa919f7a014f923c83a7ead1a"></a>
bool&#160;</td><td class="memItemRight" valign="bottom"><b>WasLocalDetachSent</b><code> [get]</code></td></tr>
<tr class="separator:ab32bcd2fa919f7a014f923c83a7ead1a inherit properties_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="inherit_header properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IReceiver"><td colspan="2" onclick="javascript:toggleInherit('properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IReceiver')"><img src="closed.png" alt="-"/>&#160;Properties inherited from <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IReceiver.html">Apache.Qpid.Proton.Engine.IReceiver</a></td></tr>
<tr class="memitem:a5ddbd8c76dead594943fab3bd1ed60a6 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IReceiver"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Types_1_1Transport_1_1IDeliveryState.html">IDeliveryState</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IReceiver.html#a5ddbd8c76dead594943fab3bd1ed60a6">DefaultDeliveryState</a><code> [get, set]</code></td></tr>
<tr class="memdesc:a5ddbd8c76dead594943fab3bd1ed60a6 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IReceiver"><td class="mdescLeft">&#160;</td><td class="mdescRight">Configures a default DeliveryState to be used if a received delivery is settled/freed without any disposition state having been previously applied.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IReceiver.html#a5ddbd8c76dead594943fab3bd1ed60a6">More...</a><br /></td></tr>
<tr class="separator:a5ddbd8c76dead594943fab3bd1ed60a6 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IReceiver"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a00f8ee2af86ac122c6da55bc8900847a inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IReceiver"><td class="memItemLeft" align="right" valign="top">IReadOnlyCollection&lt; <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IIncomingDelivery.html">IIncomingDelivery</a> &gt;&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IReceiver.html#a00f8ee2af86ac122c6da55bc8900847a">Unsettled</a><code> [get]</code></td></tr>
<tr class="memdesc:a00f8ee2af86ac122c6da55bc8900847a inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IReceiver"><td class="mdescLeft">&#160;</td><td class="mdescRight">Retrieves the list of unsettled deliveries sent from this receiver. The deliveries in the enumerator cannot be written to but can have their settled state and disposition updated. Only when this receiver settles on its end are the outgoing delivery instances removed from the unsettled tracking.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IReceiver.html#a00f8ee2af86ac122c6da55bc8900847a">More...</a><br /></td></tr>
<tr class="separator:a00f8ee2af86ac122c6da55bc8900847a inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IReceiver"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a1bff9f5e420dda289bf0a8c7cfdf4974 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IReceiver"><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_1Engine_1_1IReceiver.html#a1bff9f5e420dda289bf0a8c7cfdf4974">HasUnsettled</a><code> [get]</code></td></tr>
<tr class="memdesc:a1bff9f5e420dda289bf0a8c7cfdf4974 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IReceiver"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns true if the receiver link is tracking any unsettled sent deliveries.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IReceiver.html#a1bff9f5e420dda289bf0a8c7cfdf4974">More...</a><br /></td></tr>
<tr class="separator:a1bff9f5e420dda289bf0a8c7cfdf4974 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IReceiver"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="inherit_header properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td colspan="2" onclick="javascript:toggleInherit('properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink')"><img src="closed.png" alt="-"/>&#160;Properties inherited from <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html">Apache.Qpid.Proton.Engine.ILink&lt; T &gt;</a></td></tr>
<tr class="memitem:ac24b688eb4dfec81ea8b618a335740bc inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><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_1Engine_1_1ILink.html#ac24b688eb4dfec81ea8b618a335740bc">IsLocallyDetached</a><code> [get]</code></td></tr>
<tr class="memdesc:ac24b688eb4dfec81ea8b618a335740bc inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns true if the endpoint having been previously locally opened is now detached due to a call the the detach method. This does not reflect the state of the remote endpoint and that should be checked separately.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#ac24b688eb4dfec81ea8b618a335740bc">More...</a><br /></td></tr>
<tr class="separator:ac24b688eb4dfec81ea8b618a335740bc inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a6637864fad61b5f622e94fb466dd0e42 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><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_1Engine_1_1ILink.html#a6637864fad61b5f622e94fb466dd0e42">IsLocallyClosedOrDetached</a><code> [get]</code></td></tr>
<tr class="memdesc:a6637864fad61b5f622e94fb466dd0e42 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns true if the endpoint having been previously locally opened is now detached or closed due to a call to either the close method or the detach method. This does not reflect the state of the remote endpoint and that should be checked separately.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#a6637864fad61b5f622e94fb466dd0e42">More...</a><br /></td></tr>
<tr class="separator:a6637864fad61b5f622e94fb466dd0e42 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a5a438f92bc696dbafe0cf9256d271e75 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memItemLeft" align="right" valign="top"><a class="el" href="namespaceApache_1_1Qpid_1_1Proton_1_1Engine.html#acbdc8141247342461fc88ea23eac6ad6">LinkState</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#a5a438f92bc696dbafe0cf9256d271e75">LinkState</a><code> [get]</code></td></tr>
<tr class="memdesc:a5a438f92bc696dbafe0cf9256d271e75 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Gets the current state of the local end of the link object.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#a5a438f92bc696dbafe0cf9256d271e75">More...</a><br /></td></tr>
<tr class="separator:a5a438f92bc696dbafe0cf9256d271e75 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a8cbcbd1237553130405839dd0d96a77a inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memItemLeft" align="right" valign="top">uint&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#a8cbcbd1237553130405839dd0d96a77a">Credit</a><code> [get]</code></td></tr>
<tr class="memdesc:a8cbcbd1237553130405839dd0d96a77a inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Reads the credit that is currently available on or assigned to this link object.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#a8cbcbd1237553130405839dd0d96a77a">More...</a><br /></td></tr>
<tr class="separator:a8cbcbd1237553130405839dd0d96a77a inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a8cb0c35d16b23898bb517a01e4c4af33 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><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_1Engine_1_1ILink.html#a8cb0c35d16b23898bb517a01e4c4af33">IsDraining</a><code> [get]</code></td></tr>
<tr class="memdesc:a8cb0c35d16b23898bb517a01e4c4af33 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Indicates if the link is draining. For a sender link this indicates that the remote has requested that the sender transmit deliveries up to the currently available credit or indicate that it has no more to send. For a receiver this indicates that the Receiver has requested that the remote sender consume its outstanding credit.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#a8cb0c35d16b23898bb517a01e4c4af33">More...</a><br /></td></tr>
<tr class="separator:a8cb0c35d16b23898bb517a01e4c4af33 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ab15e51a98bbde46e6fe61b724f80ab17 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memItemLeft" align="right" valign="top"><a class="el" href="namespaceApache_1_1Qpid_1_1Proton_1_1Types_1_1Transport.html#a5f514350b2297fec543826213ed83cd4">Role</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#ab15e51a98bbde46e6fe61b724f80ab17">Role</a><code> [get]</code></td></tr>
<tr class="memdesc:ab15e51a98bbde46e6fe61b724f80ab17 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Reads the role assigned to the local end of the link.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#ab15e51a98bbde46e6fe61b724f80ab17">More...</a><br /></td></tr>
<tr class="separator:ab15e51a98bbde46e6fe61b724f80ab17 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ab8f0c167ebaa289113c6c91ca1e3ee51 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><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_1Engine_1_1ILink.html#ab8f0c167ebaa289113c6c91ca1e3ee51">IsSender</a><code> [get]</code></td></tr>
<tr class="memdesc:ab8f0c167ebaa289113c6c91ca1e3ee51 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns if this link is a sender link.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#ab8f0c167ebaa289113c6c91ca1e3ee51">More...</a><br /></td></tr>
<tr class="separator:ab8f0c167ebaa289113c6c91ca1e3ee51 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a5c4a8feccfc607d1cf6d94e4aa710391 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><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_1Engine_1_1ILink.html#a5c4a8feccfc607d1cf6d94e4aa710391">IsReceiver</a><code> [get]</code></td></tr>
<tr class="memdesc:a5c4a8feccfc607d1cf6d94e4aa710391 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns if this link is a receiver link.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#a5c4a8feccfc607d1cf6d94e4aa710391">More...</a><br /></td></tr>
<tr class="separator:a5c4a8feccfc607d1cf6d94e4aa710391 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a288a8100df3231216eec79eb39427a03 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IConnection.html">IConnection</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#a288a8100df3231216eec79eb39427a03">Connection</a><code> [get]</code></td></tr>
<tr class="memdesc:a288a8100df3231216eec79eb39427a03 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Provides access to the connection that owns this sender endpoint.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#a288a8100df3231216eec79eb39427a03">More...</a><br /></td></tr>
<tr class="separator:a288a8100df3231216eec79eb39427a03 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ab578133eba2e8bd8fb2495714d20d5a2 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ISession.html">ISession</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#ab578133eba2e8bd8fb2495714d20d5a2">Session</a><code> [get]</code></td></tr>
<tr class="memdesc:ab578133eba2e8bd8fb2495714d20d5a2 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Provides access to the session that owns this sender endpoint.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#ab578133eba2e8bd8fb2495714d20d5a2">More...</a><br /></td></tr>
<tr class="separator:ab578133eba2e8bd8fb2495714d20d5a2 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ade03463cbfde7406b349e2b25922c3d2 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memItemLeft" align="right" valign="top">string&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#ade03463cbfde7406b349e2b25922c3d2">Name</a><code> [get]</code></td></tr>
<tr class="memdesc:ade03463cbfde7406b349e2b25922c3d2 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Access the name that was given to the link on creation.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#ade03463cbfde7406b349e2b25922c3d2">More...</a><br /></td></tr>
<tr class="separator:ade03463cbfde7406b349e2b25922c3d2 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:af753b9e8d30629f6a5904300dab489f0 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memItemLeft" align="right" valign="top">SenderSettleMode&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#af753b9e8d30629f6a5904300dab489f0">SenderSettleMode</a><code> [get, set]</code></td></tr>
<tr class="memdesc:af753b9e8d30629f6a5904300dab489f0 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Access the sender settle mode. Should only be called during link set-up, i.e. before calling open. If this endpoint is the initiator of the link, this method can be used to set a value other than the default. If this endpoint is not the initiator, this method should be used to set a local value. According to the AMQP spec, the application may choose to accept the sender's suggestion (accessed by calling the remote sender settle mode API) or choose another value. The value has no effect on <a class="el" href="namespaceApache_1_1Qpid_1_1Proton.html">Proton</a>, but may be useful to the application at a later point. In order to be AMQP compliant the application is responsible for honoring the settlement mode.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#af753b9e8d30629f6a5904300dab489f0">More...</a><br /></td></tr>
<tr class="separator:af753b9e8d30629f6a5904300dab489f0 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a70d509b08ca4ea75cbf4a4c4462aedc0 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memItemLeft" align="right" valign="top">ReceiverSettleMode&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#a70d509b08ca4ea75cbf4a4c4462aedc0">ReceiverSettleMode</a><code> [get, set]</code></td></tr>
<tr class="memdesc:a70d509b08ca4ea75cbf4a4c4462aedc0 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Access the receiver settle mode. Should only be called during link set-up, i.e. before calling open. If this endpoint is the initiator of the link, this method can be used to set a value other than the default.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#a70d509b08ca4ea75cbf4a4c4462aedc0">More...</a><br /></td></tr>
<tr class="separator:a70d509b08ca4ea75cbf4a4c4462aedc0 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:af9c4274e303966d6a803bf44089d9ace inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Types_1_1Messaging_1_1Source.html">Source</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#af9c4274e303966d6a803bf44089d9ace">Source</a><code> [get, set]</code></td></tr>
<tr class="memdesc:af9c4274e303966d6a803bf44089d9ace inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Sets the Source value to assign to the local end of this link. Must be called during link setup, i.e. before calling the open method.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#af9c4274e303966d6a803bf44089d9ace">More...</a><br /></td></tr>
<tr class="separator:af9c4274e303966d6a803bf44089d9ace inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a1c1720215751f6d9159231d17af4ae31 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Types_1_1Messaging_1_1Source.html">Source</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#a1c1720215751f6d9159231d17af4ae31">RemoteSource</a><code> [get]</code></td></tr>
<tr class="memdesc:a1c1720215751f6d9159231d17af4ae31 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Gets the Source value that was assigned by the remote end of the link.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#a1c1720215751f6d9159231d17af4ae31">More...</a><br /></td></tr>
<tr class="separator:a1c1720215751f6d9159231d17af4ae31 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a5c9d3f0e775f3b44a98ae40ce9499256 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Types_1_1Messaging_1_1ITerminus.html">ITerminus</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#a5c9d3f0e775f3b44a98ae40ce9499256">Terminus</a><code> [get, set]</code></td></tr>
<tr class="memdesc:a5c9d3f0e775f3b44a98ae40ce9499256 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Gets the local Target terminus value as a generic terminus instance which the user can then interrogate to determine if it is a Target or a Coordinator instance. When set the value must be one of Target or Coordinator.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#a5c9d3f0e775f3b44a98ae40ce9499256">More...</a><br /></td></tr>
<tr class="separator:a5c9d3f0e775f3b44a98ae40ce9499256 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a1de222a0bc42d2c726ef54dcc7cb776b inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Types_1_1Messaging_1_1ITerminus.html">ITerminus</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#a1de222a0bc42d2c726ef54dcc7cb776b">RemoteTerminus</a><code> [get]</code></td></tr>
<tr class="memdesc:a1de222a0bc42d2c726ef54dcc7cb776b inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Get the remote set Terminus either Target or Coordinator that is set once the remote sends its attach frame.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#a1de222a0bc42d2c726ef54dcc7cb776b">More...</a><br /></td></tr>
<tr class="separator:a1de222a0bc42d2c726ef54dcc7cb776b inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:aacb8050c3b040628d4aae11765e7b66a inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Types_1_1Transactions_1_1Coordinator.html">Coordinator</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#aacb8050c3b040628d4aae11765e7b66a">Coordinator</a><code> [get, set]</code></td></tr>
<tr class="memdesc:aacb8050c3b040628d4aae11765e7b66a inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Attempt to access the local target terminus value as a Coordinator value. When reading if the target terminus is not a Coordinator the result is null. Must be called during link setup, i.e. before calling the open method.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#aacb8050c3b040628d4aae11765e7b66a">More...</a><br /></td></tr>
<tr class="separator:aacb8050c3b040628d4aae11765e7b66a inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a375643dc9fd0bb34eca33f5f99dd2dbe inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Types_1_1Messaging_1_1Target.html">Target</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#a375643dc9fd0bb34eca33f5f99dd2dbe">Target</a><code> [get, set]</code></td></tr>
<tr class="memdesc:a375643dc9fd0bb34eca33f5f99dd2dbe inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Attempt to access the local target terminus value as a Target value. When reading if the target terminus is not a Target the result is null. Must be called during link setup, i.e. before calling the open method.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#a375643dc9fd0bb34eca33f5f99dd2dbe">More...</a><br /></td></tr>
<tr class="separator:a375643dc9fd0bb34eca33f5f99dd2dbe inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a08f036e574879fcbdbb9370a15e700eb inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memItemLeft" align="right" valign="top">ulong&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#a08f036e574879fcbdbb9370a15e700eb">MaxMessageSize</a><code> [get, set]</code></td></tr>
<tr class="memdesc:a08f036e574879fcbdbb9370a15e700eb inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Sets the local link max message size, to be conveyed to the peer via the Attach frame when attaching the link to the session. Null or 0 means no limit. Must be called during link setup, i.e. before calling the open method.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#a08f036e574879fcbdbb9370a15e700eb">More...</a><br /></td></tr>
<tr class="separator:a08f036e574879fcbdbb9370a15e700eb inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:adc9f6830c1cc5c0fc28db324599f5e22 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><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_1Engine_1_1ILink.html#adc9f6830c1cc5c0fc28db324599f5e22">IsRemotelyDetached</a><code> [get]</code></td></tr>
<tr class="memdesc:adc9f6830c1cc5c0fc28db324599f5e22 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns true if this link is currently remotely detached meaning the state returned from the remote state accessor is equal to detached. A link is remotely detached after an Detach performative has been received from the remote with the close flag equal to false.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#adc9f6830c1cc5c0fc28db324599f5e22">More...</a><br /></td></tr>
<tr class="separator:adc9f6830c1cc5c0fc28db324599f5e22 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ae7089cf08e3acb8ea13fc73b48bbd9ff inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><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_1Engine_1_1ILink.html#ae7089cf08e3acb8ea13fc73b48bbd9ff">IsRemotelyClosedOrDetached</a><code> [get]</code></td></tr>
<tr class="memdesc:ae7089cf08e3acb8ea13fc73b48bbd9ff inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns true if this link is currently remotely detached or closed meaning the state returned from the remote state accessor is equal to detached or to closed. A link is remotely detached after an Detach performative has been received from the remote with the close flag equal to false otherwise is considered closed..  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#ae7089cf08e3acb8ea13fc73b48bbd9ff">More...</a><br /></td></tr>
<tr class="separator:ae7089cf08e3acb8ea13fc73b48bbd9ff inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a96b0fc29e007812c692caf0da8c121fd inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#af753b9e8d30629f6a5904300dab489f0">SenderSettleMode</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#a96b0fc29e007812c692caf0da8c121fd">RemoteSenderSettleMode</a><code> [get]</code></td></tr>
<tr class="memdesc:a96b0fc29e007812c692caf0da8c121fd inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Gets the remote link sender settlement mode, as conveyed from the peer via the Attach frame when attaching the link to the session.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#a96b0fc29e007812c692caf0da8c121fd">More...</a><br /></td></tr>
<tr class="separator:a96b0fc29e007812c692caf0da8c121fd inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a06f8730963d22ca5d109ffb26f26bc8f inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#a70d509b08ca4ea75cbf4a4c4462aedc0">ReceiverSettleMode</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#a06f8730963d22ca5d109ffb26f26bc8f">RemoteReceiverSettleMode</a><code> [get]</code></td></tr>
<tr class="memdesc:a06f8730963d22ca5d109ffb26f26bc8f inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Gets the remote link receiver settlement mode, as conveyed from the peer via the Attach frame when attaching the link to the session.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#a06f8730963d22ca5d109ffb26f26bc8f">More...</a><br /></td></tr>
<tr class="separator:a06f8730963d22ca5d109ffb26f26bc8f inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a7b46c5c0c130712b44c9a3fff811fd95 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memItemLeft" align="right" valign="top"><a class="el" href="namespaceApache_1_1Qpid_1_1Proton_1_1Engine.html#acbdc8141247342461fc88ea23eac6ad6">LinkState</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#a7b46c5c0c130712b44c9a3fff811fd95">RemoteState</a><code> [get]</code></td></tr>
<tr class="memdesc:a7b46c5c0c130712b44c9a3fff811fd95 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Gets the current remote link state.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink.html#a7b46c5c0c130712b44c9a3fff811fd95">More...</a><br /></td></tr>
<tr class="separator:a7b46c5c0c130712b44c9a3fff811fd95 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1ILink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="inherit_header properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td colspan="2" onclick="javascript:toggleInherit('properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint')"><img src="closed.png" alt="-"/>&#160;Properties inherited from <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint.html">Apache.Qpid.Proton.Engine.IEndpoint&lt; T &gt;</a></td></tr>
<tr class="memitem:acf2de4c97690fa4fd673461dcbb37db5 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEngine.html">IEngine</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint.html#acf2de4c97690fa4fd673461dcbb37db5">Engine</a><code> [get]</code></td></tr>
<tr class="memdesc:acf2de4c97690fa4fd673461dcbb37db5 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="mdescLeft">&#160;</td><td class="mdescRight">Provides access to the engine instance that owns the resources of this endpoint and its parent.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint.html#acf2de4c97690fa4fd673461dcbb37db5">More...</a><br /></td></tr>
<tr class="separator:acf2de4c97690fa4fd673461dcbb37db5 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ac2fb9813280c594a67f269c99b127686 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IAttachments.html">IAttachments</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint.html#ac2fb9813280c594a67f269c99b127686">Attachments</a><code> [get]</code></td></tr>
<tr class="memdesc:ac2fb9813280c594a67f269c99b127686 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="mdescLeft">&#160;</td><td class="mdescRight">Access the attachments instance that is associated with this resource where the application can store data relevant to the endpoint for later use.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint.html#ac2fb9813280c594a67f269c99b127686">More...</a><br /></td></tr>
<tr class="separator:ac2fb9813280c594a67f269c99b127686 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a25bdf8458c47a47339a23de1b5667540 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><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_1Engine_1_1IEndpoint.html#a25bdf8458c47a47339a23de1b5667540">LinkedResource</a><code> [get, set]</code></td></tr>
<tr class="memdesc:a25bdf8458c47a47339a23de1b5667540 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="mdescLeft">&#160;</td><td class="mdescRight">Allows the endpoint to have some user defined resource linked to it which can be used to store application state data or other associated object instances with this endpoint.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint.html#a25bdf8458c47a47339a23de1b5667540">More...</a><br /></td></tr>
<tr class="separator:a25bdf8458c47a47339a23de1b5667540 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a483d1c5582cbeeec1b97be0ba0da8f0a inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Types_1_1Transport_1_1ErrorCondition.html">ErrorCondition</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint.html#a483d1c5582cbeeec1b97be0ba0da8f0a">ErrorCondition</a><code> [get, set]</code></td></tr>
<tr class="memdesc:a483d1c5582cbeeec1b97be0ba0da8f0a inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="mdescLeft">&#160;</td><td class="mdescRight">Provides access to the error condition that should be applied to the AMQP frame that closes or ends this endpoint when the close method is called be the user. Setting this value after closing the endpoint has no effect.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint.html#a483d1c5582cbeeec1b97be0ba0da8f0a">More...</a><br /></td></tr>
<tr class="separator:a483d1c5582cbeeec1b97be0ba0da8f0a inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a4578fff3125a050d7126952b7fde08b2 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Types_1_1Transport_1_1ErrorCondition.html">ErrorCondition</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint.html#a4578fff3125a050d7126952b7fde08b2">RemoteErrorCondition</a><code> [get]</code></td></tr>
<tr class="memdesc:a4578fff3125a050d7126952b7fde08b2 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="mdescLeft">&#160;</td><td class="mdescRight">If the remote has closed this endpoint and provided an ErrorCondition as part of the closing AMQP performative then this method will return it.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint.html#a4578fff3125a050d7126952b7fde08b2">More...</a><br /></td></tr>
<tr class="separator:a4578fff3125a050d7126952b7fde08b2 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a6395c22a29e16f3f90f67729b2bc9d1a inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><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_1Engine_1_1IEndpoint.html#a6395c22a29e16f3f90f67729b2bc9d1a">IsLocallyOpen</a><code> [get]</code></td></tr>
<tr class="memdesc:a6395c22a29e16f3f90f67729b2bc9d1a inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns true if the endpoint open was previously called and the close method has not yet been invoked. This only reflects the state on the local end and the user should also check the remote state.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint.html#a6395c22a29e16f3f90f67729b2bc9d1a">More...</a><br /></td></tr>
<tr class="separator:a6395c22a29e16f3f90f67729b2bc9d1a inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ab33b409da9ba52367721407ab4bbd31f inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><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_1Engine_1_1IEndpoint.html#ab33b409da9ba52367721407ab4bbd31f">IsLocallyClosed</a><code> [get]</code></td></tr>
<tr class="memdesc:ab33b409da9ba52367721407ab4bbd31f inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns true if the endpoint having been previously locally opened is now closed due to a call the the close method. This does not reflect the state of the remote endpoint and that should be checked separately.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint.html#ab33b409da9ba52367721407ab4bbd31f">More...</a><br /></td></tr>
<tr class="separator:ab33b409da9ba52367721407ab4bbd31f inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a94174c5f25e62b8b95492a92c6f4e63a inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><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_1Engine_1_1IEndpoint.html#a94174c5f25e62b8b95492a92c6f4e63a">IsRemotelyOpen</a><code> [get]</code></td></tr>
<tr class="memdesc:a94174c5f25e62b8b95492a92c6f4e63a inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns true if this endpoint is currently remotely open meaning that the AMQP performative that completes the open phase of this endpoint's lifetime has arrived but the performative that closes it has not.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint.html#a94174c5f25e62b8b95492a92c6f4e63a">More...</a><br /></td></tr>
<tr class="separator:a94174c5f25e62b8b95492a92c6f4e63a inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ac4457742b6167578c6cfffdc0bec405b inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><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_1Engine_1_1IEndpoint.html#ac4457742b6167578c6cfffdc0bec405b">IsRemotelyClosed</a><code> [get]</code></td></tr>
<tr class="memdesc:ac4457742b6167578c6cfffdc0bec405b inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns true if this endpoint is currently remotely closed meaning that the AMQP performative that completes the close phase of this endpoint's lifetime has arrived.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint.html#ac4457742b6167578c6cfffdc0bec405b">More...</a><br /></td></tr>
<tr class="separator:ac4457742b6167578c6cfffdc0bec405b inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:aca301979e4ab47a2ff142966e073ccfd inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Types_1_1Symbol.html">Symbol</a>[]&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint.html#aca301979e4ab47a2ff142966e073ccfd">OfferedCapabilities</a><code> [get, set]</code></td></tr>
<tr class="memdesc:aca301979e4ab47a2ff142966e073ccfd inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="mdescLeft">&#160;</td><td class="mdescRight">Access the capabilities to be offered on to the remote when this endpoint is opened. The offered capabilities value can only be modified prior to a call to open, once the endpoint has been opened locally an error will be thrown if this method is called.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint.html#aca301979e4ab47a2ff142966e073ccfd">More...</a><br /></td></tr>
<tr class="separator:aca301979e4ab47a2ff142966e073ccfd inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:aa5a2b6e00125c05df60fe373c1368366 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Types_1_1Symbol.html">Symbol</a>[]&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint.html#aa5a2b6e00125c05df60fe373c1368366">DesiredCapabilities</a><code> [get, set]</code></td></tr>
<tr class="memdesc:aa5a2b6e00125c05df60fe373c1368366 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="mdescLeft">&#160;</td><td class="mdescRight">Access the capabilities that are desired on to the remote when this endpoint is opened. The desired capabilities value can only be modified prior to a call to open, once the endpoint has been opened locally an error will be thrown if this method is called.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint.html#aa5a2b6e00125c05df60fe373c1368366">More...</a><br /></td></tr>
<tr class="separator:aa5a2b6e00125c05df60fe373c1368366 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:adc18f13e8a13f1cb9c891f0a89479db5 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="memItemLeft" align="right" valign="top">IReadOnlyDictionary&lt; <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Types_1_1Symbol.html">Symbol</a>, object &gt;&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint.html#adc18f13e8a13f1cb9c891f0a89479db5">Properties</a><code> [get, set]</code></td></tr>
<tr class="memdesc:adc18f13e8a13f1cb9c891f0a89479db5 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="mdescLeft">&#160;</td><td class="mdescRight">Access the properties that are conveyed to the remote when this endpoint is opened. The properties value can only be modified prior to a call to open, once the endpoint has been opened locally an error will be thrown if this method is called.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint.html#adc18f13e8a13f1cb9c891f0a89479db5">More...</a><br /></td></tr>
<tr class="separator:adc18f13e8a13f1cb9c891f0a89479db5 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a5b30574efe967b7c8b2be36fce5c086b inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Types_1_1Symbol.html">Symbol</a>[]&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint.html#a5b30574efe967b7c8b2be36fce5c086b">RemoteOfferedCapabilities</a><code> [get]</code></td></tr>
<tr class="memdesc:a5b30574efe967b7c8b2be36fce5c086b inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="mdescLeft">&#160;</td><td class="mdescRight">The capabilities offered by the remote when it opened its end of the endpoint.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint.html#a5b30574efe967b7c8b2be36fce5c086b">More...</a><br /></td></tr>
<tr class="separator:a5b30574efe967b7c8b2be36fce5c086b inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:afb420de3356b1ca05f2f9f109262916b inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="memItemLeft" align="right" valign="top"><a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Types_1_1Symbol.html">Symbol</a>[]&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint.html#afb420de3356b1ca05f2f9f109262916b">RemoteDesiredCapabilities</a><code> [get]</code></td></tr>
<tr class="memdesc:afb420de3356b1ca05f2f9f109262916b inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="mdescLeft">&#160;</td><td class="mdescRight">The capabilities desired by the remote when it opened its end of the endpoint.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint.html#afb420de3356b1ca05f2f9f109262916b">More...</a><br /></td></tr>
<tr class="separator:afb420de3356b1ca05f2f9f109262916b inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a7bef5964f1a780579627bbc569a05028 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="memItemLeft" align="right" valign="top">IReadOnlyDictionary&lt; <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Types_1_1Symbol.html">Symbol</a>, object &gt;&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint.html#a7bef5964f1a780579627bbc569a05028">RemoteProperties</a><code> [get]</code></td></tr>
<tr class="memdesc:a7bef5964f1a780579627bbc569a05028 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="mdescLeft">&#160;</td><td class="mdescRight">The properties sent by the remote when it opened its end of this endpoint.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint.html#a7bef5964f1a780579627bbc569a05028">More...</a><br /></td></tr>
<tr class="separator:a7bef5964f1a780579627bbc569a05028 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IEndpoint"><td class="memSeparator" colspan="2">&#160;</td></tr>
</table><table class="memberdecls">
<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
Additional Inherited Members</h2></td></tr>
<tr class="inherit_header pro_attribs_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink')"><img src="closed.png" alt="-"/>&#160;Protected Attributes inherited from <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink.html">Apache.Qpid.Proton.Engine.Implementation.ProtonLink&lt; IReceiver &gt;</a></td></tr>
<tr class="memitem:ac30f9b5003b4f399230c49d0ed8fd3a5 inherit pro_attribs_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="ac30f9b5003b4f399230c49d0ed8fd3a5"></a>
readonly <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonConnection.html">ProtonConnection</a>&#160;</td><td class="memItemRight" valign="bottom"><b>connection</b></td></tr>
<tr class="separator:ac30f9b5003b4f399230c49d0ed8fd3a5 inherit pro_attribs_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a907608f83bb75b066be24866095e14c1 inherit pro_attribs_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="a907608f83bb75b066be24866095e14c1"></a>
readonly <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonSession.html">ProtonSession</a>&#160;</td><td class="memItemRight" valign="bottom"><b>session</b></td></tr>
<tr class="separator:a907608f83bb75b066be24866095e14c1 inherit pro_attribs_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a40998b4ae728f02700bde6d0e6ff3927 inherit pro_attribs_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="a40998b4ae728f02700bde6d0e6ff3927"></a>
readonly <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Types_1_1Transport_1_1Attach.html">Attach</a>&#160;</td><td class="memItemRight" valign="bottom"><b>localAttach</b></td></tr>
<tr class="separator:a40998b4ae728f02700bde6d0e6ff3927 inherit pro_attribs_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a2819c99ab1e3c781446d87604423fb74 inherit pro_attribs_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><td class="memItemLeft" align="right" valign="top"><a id="a2819c99ab1e3c781446d87604423fb74"></a>
<a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Types_1_1Transport_1_1Attach.html">Attach</a>&#160;</td><td class="memItemRight" valign="bottom"><b>remoteAttach</b></td></tr>
<tr class="separator:a2819c99ab1e3c781446d87604423fb74 inherit pro_attribs_classApache_1_1Qpid_1_1Proton_1_1Engine_1_1Implementation_1_1ProtonLink"><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><a class="el" href="namespaceApache_1_1Qpid_1_1Proton.html">Proton</a> Receiver link implementation which manages the receipt of new deliveries and credit associated with the link. Delivery outcomes and settlement states can also be managed from the receiver link. </p>
</div><h2 class="groupheader">Member Function Documentation</h2>
<a id="afd2b1038cd2cc3c5426fe7738df3d870"></a>
<h2 class="memtitle"><span class="permalink"><a href="#afd2b1038cd2cc3c5426fe7738df3d870">&#9670;&nbsp;</a></span>AddCredit()</h2>

<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IReceiver.html">IReceiver</a> Apache.Qpid.Proton.Engine.Implementation.ProtonReceiver.AddCredit </td>
          <td>(</td>
          <td class="paramtype">uint&#160;</td>
          <td class="paramname"><em>amount</em></td><td>)</td>
          <td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Adds the given amount of credit to the receiver's already existing credit if any. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">amount</td><td>The amount of credit to add to the existing credit</td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>This receiver instance</dd></dl>

<p>Implements <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IReceiver.html#adbc93b27c73d134f2e946a2d5cae7d5f">Apache.Qpid.Proton.Engine.IReceiver</a>.</p>

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

<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IReceiver.html">IReceiver</a> Apache.Qpid.Proton.Engine.Implementation.ProtonReceiver.DeliveryAbortedHandler </td>
          <td>(</td>
          <td class="paramtype">Action&lt; <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IIncomingDelivery.html">IIncomingDelivery</a> &gt;&#160;</td>
          <td class="paramname"><em>handler</em></td><td>)</td>
          <td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Handler for aborted deliveries that is called for each aborted in-progress delivery. This handler is an optional convenience handler that supplements the standard delivery read event handler in cases where the users wishes to break out the processing of inbound delivery data from abort processing. If this handler is not set the receiver will call the registered delivery read handler if one is set. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">handler</td><td>A delegate that will handle this event</td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>This receiver instance</dd></dl>

<p>Implements <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IReceiver.html#aaaea47cc3df272dcd212cb70960fc113">Apache.Qpid.Proton.Engine.IReceiver</a>.</p>

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

<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IReceiver.html">IReceiver</a> Apache.Qpid.Proton.Engine.Implementation.ProtonReceiver.DeliveryReadHandler </td>
          <td>(</td>
          <td class="paramtype">Action&lt; <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IIncomingDelivery.html">IIncomingDelivery</a> &gt;&#160;</td>
          <td class="paramname"><em>handler</em></td><td>)</td>
          <td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Handler for incoming deliveries that is called for each incoming transfer frame that comprises either one complete delivery or a chunk of a split framed transfer. The handler should check that the delivery being read is partial or not and act accordingly, as partial deliveries expect additional updates as more frames comprising that delivery arrive or the remote aborts the transfer. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">handler</td><td>A delegate that will handle this event</td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>This receiver instance</dd></dl>

<p>Implements <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IReceiver.html#aaa566bb43a12a893766e1c476f47676d">Apache.Qpid.Proton.Engine.IReceiver</a>.</p>

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

<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IReceiver.html">IReceiver</a> Apache.Qpid.Proton.Engine.Implementation.ProtonReceiver.DeliveryStateUpdatedHandler </td>
          <td>(</td>
          <td class="paramtype">Action&lt; <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IIncomingDelivery.html">IIncomingDelivery</a> &gt;&#160;</td>
          <td class="paramname"><em>handler</em></td><td>)</td>
          <td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Handler for updates to the remote state of incoming deliveries that have previously been received. Remote state updates for an previously received delivery can happen when the remote settles a complete delivery or otherwise modifies the delivery outcome and the user needs to act on those changes such as a spontaneous update to the delivery state. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">handler</td><td>A delegate that will handle this event</td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>This receiver instance</dd></dl>

<p>Implements <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IReceiver.html#a4e0c2b2be1d6ce82b50b06b85e256379">Apache.Qpid.Proton.Engine.IReceiver</a>.</p>

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

<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IReceiver.html">IReceiver</a> Apache.Qpid.Proton.Engine.Implementation.ProtonReceiver.Disposition </td>
          <td>(</td>
          <td class="paramtype">Predicate&lt; <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IIncomingDelivery.html">IIncomingDelivery</a> &gt;&#160;</td>
          <td class="paramname"><em>filter</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Types_1_1Transport_1_1IDeliveryState.html">IDeliveryState</a>&#160;</td>
          <td class="paramname"><em>state</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">bool&#160;</td>
          <td class="paramname"><em>settle</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>For each unsettled outgoing delivery that is pending in the receiver apply the given predicate and if it matches then apply the given delivery state and settled value to it. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">filter</td><td>The filter predicate that controls when disposition is applied</td></tr>
    <tr><td class="paramname">state</td><td>The delivery state to apply when the predicate matches</td></tr>
    <tr><td class="paramname">settle</td><td>Should the delivery be settled when the predicate matches.</td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>This receiver instance</dd></dl>

<p>Implements <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IReceiver.html#a61d396902752edba126fa1ad3de744ea">Apache.Qpid.Proton.Engine.IReceiver</a>.</p>

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

<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">bool Apache.Qpid.Proton.Engine.Implementation.ProtonReceiver.Drain </td>
          <td>(</td>
          <td class="paramname"></td><td>)</td>
          <td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Initiate a drain of all remaining credit of this link, the remote sender will then either send enough deliveries to fulfill the drain request or report that it cannot and all remaining link credit will be consumed. </p>
<dl class="section return"><dt>Returns</dt><dd>True if a drain request was started or false if no credit exists</dd></dl>
<dl class="exception"><dt>Exceptions</dt><dd>
  <table class="exception">
    <tr><td class="paramname">InvalidOperationException</td><td>If a drain is already in progress</td></tr>
  </table>
  </dd>
</dl>

<p>Implements <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IReceiver.html#a4fc5e28e070c23ba81c1e00161eb1f7c">Apache.Qpid.Proton.Engine.IReceiver</a>.</p>

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

<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">bool Apache.Qpid.Proton.Engine.Implementation.ProtonReceiver.Drain </td>
          <td>(</td>
          <td class="paramtype">uint&#160;</td>
          <td class="paramname"><em>credit</em></td><td>)</td>
          <td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Initiate a drain of the given credit from this this receiver} link. If the credit given is greater than the current link credit the current credit is increased, however if the amount of credit given is less that the current amount of link credit an exception is thrown. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">credit</td><td>The amount of credit to drain</td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>True if a drain request was started or false if no credit exists</dd></dl>
<dl class="exception"><dt>Exceptions</dt><dd>
  <table class="exception">
    <tr><td class="paramname">InvalidOperationException</td><td>If a drain is already in progress</td></tr>
  </table>
  </dd>
</dl>

<p>Implements <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IReceiver.html#ae9fe22489b62dab36a6001db47e30df1">Apache.Qpid.Proton.Engine.IReceiver</a>.</p>

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

<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IReceiver.html">IReceiver</a> Apache.Qpid.Proton.Engine.Implementation.ProtonReceiver.Settle </td>
          <td>(</td>
          <td class="paramtype">Predicate&lt; <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IIncomingDelivery.html">IIncomingDelivery</a> &gt;&#160;</td>
          <td class="paramname"><em>filter</em></td><td>)</td>
          <td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>For each unsettled outgoing delivery that is pending in the receiver apply the given predicate and if it matches then settle the delivery. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">filter</td><td></td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>This receiver instance</dd></dl>

<p>Implements <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IReceiver.html#a2f850eda35158fb8725f352e66d8aa77">Apache.Qpid.Proton.Engine.IReceiver</a>.</p>

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