You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@qpid.apache.org by jr...@apache.org on 2016/04/14 20:29:38 UTC
svn commit: r1739159 [36/45] - in
/qpid/site/docs/releases/qpid-proton-master: ./ proton/c/api/
proton/c/api/search/ proton/cpp/api/ proton/cpp/api/search/
proton/cpp/examples/ proton/java/api/
proton/java/api/org/apache/qpid/proton/engine/ proton/java...
Modified: qpid/site/docs/releases/qpid-proton-master/proton/cpp/api/tutorial.html
URL: http://svn.apache.org/viewvc/qpid/site/docs/releases/qpid-proton-master/proton/cpp/api/tutorial.html?rev=1739159&r1=1739158&r2=1739159&view=diff
==============================================================================
--- qpid/site/docs/releases/qpid-proton-master/proton/cpp/api/tutorial.html (original)
+++ qpid/site/docs/releases/qpid-proton-master/proton/cpp/api/tutorial.html Thu Apr 14 18:29:35 2016
@@ -95,16 +95,15 @@ $(document).ready(function(){initNavTree
<div class="contents">
<div class="textblock"><p>This is a brief tutorial that will walk you through the fundamentals of building messaging applications in incremental steps.</p>
<p>There are further examples, in addition the ones mentioned in the tutorial.</p>
-<p>Some of the examples require an AMQP <em>broker</em> that can receive, store and send messages. <a class="el" href="broker_8hpp-example.html">broker.hpp</a> and <a class="el" href="broker_8cpp-example.html">broker.cpp</a> define a simple example broker. Run without arguments it listens on <code>0.0.0.0:5672</code>, the standard AMQP port on all network interfaces. To use a different port or network interface: </p><pre class="fragment">broker -a <host>:<port>
+<p>Some of the examples require an AMQP <em>broker</em> that can receive, store and send messages. broker.hpp and broker.cpp define a simple example broker. Run without arguments it listens on <code>0.0.0.0:5672</code>, the standard AMQP port on all network interfaces. To use a different port or network interface: </p><pre class="fragment">broker -a <host>:<port>
</pre><p>Instead of the example broker, you can use any AMQP 1.0 compliant broker. You must configure your broker to have a queue (or topic) named "examples".</p>
<p>The <code>helloworld</code> examples take an optional URL argument. The other examples take an option <code>-a URL</code>. A URL looks like: </p><pre class="fragment">HOST:PORT/ADDRESS
</pre><p>It usually defaults to <code>127.0.0.1:5672/examples</code>, but you can change this if your broker is on a different host or port, or you want to use a different queue or topic name (the ADDRESS part of the URL). URL details are at <code><a class="el" href="classproton_1_1url.html" title="A proton URL. ">proton::url</a></code></p>
-<p>The first part of the tutorial uses the <code><a class="el" href="classproton_1_1container.html" title="A top-level container of connections, sessions, and links. ">proton::container</a></code>, later we will show some of the same examples implemented using the <code><a class="el" href="classproton_1_1connection__engine.html" title="An interface for connection-oriented IO integration. ">proton::connection_engine</a></code>. Most of the code is the same for either approach.</p>
+<p>The first part of the tutorial uses the <code><a class="el" href="classproton_1_1container.html" title="A top-level container of connections, sessions, and links. ">proton::container</a></code>, later we will show some of the same examples implemented using the <code>proton::connection_engine</code>. Most of the code is the same for either approach.</p>
<h2>Hello World! </h2>
-<p>Tradition dictates that we start with hello world! This example sends a message to a broker and the receives the same message back to demonstrate sending and receiving. In a realistic system the sender and receiver would normally be in different processes. The complete example is <a class="el" href="helloworld_8cpp-example.html">helloworld.cpp</a></p>
+<p>Tradition dictates that we start with hello world! This example sends a message to a broker and the receives the same message back to demonstrate sending and receiving. In a realistic system the sender and receiver would normally be in different processes. The complete example is helloworld.cpp</p>
<p>We will include the following classes: <code><a class="el" href="classproton_1_1container.html" title="A top-level container of connections, sessions, and links. ">proton::container</a></code> runs an event loop which dispatches events to a <code><a class="el" href="classproton_1_1handler.html" title="Callback functions for handling proton events. ">proton::handler</a></code>. This allows a <em>reactive</em> style of programming which is well suited to messaging applications. <code><a class="el" href="classproton_1_1url.html" title="A proton URL. ">proton::url</a></code> is a simple parser for the URL format mentioned above.</p>
<p><div class="fragment"><div class="line"><span class="preprocessor">#include "proton/container.hpp"</span></div>
-<div class="line"><span class="preprocessor">#include "proton/event.hpp"</span></div>
<div class="line"><span class="preprocessor">#include "proton/handler.hpp"</span></div>
<div class="line"><span class="preprocessor">#include "proton/url.hpp"</span></div>
</div><!-- fragment --></p>
@@ -117,80 +116,35 @@ $(document).ready(function(){initNavTree
<div class="line"> hello_world(<span class="keyword">const</span> <a class="code" href="classproton_1_1url.html">proton::url</a>& u) : url(u) {}</div>
</div><!-- fragment --></p>
<p><code>on_start()</code> is called when the event loop first starts. We handle that by establishing a connection and creating a sender and a receiver.</p>
-<p><div class="fragment"><div class="line"> <span class="keywordtype">void</span> on_start(<a class="code" href="classproton_1_1event.html">proton::event</a> &e) {</div>
-<div class="line"> <a class="code" href="classproton_1_1connection.html">proton::connection</a> conn = e.<a class="code" href="classproton_1_1event.html#a0696f6baa06a440a8c298d3d1fdde0b9">container</a>().<a class="code" href="classproton_1_1container.html#a544f214bbb007ed7c2331cbebb60c283">connect</a>(url);</div>
-<div class="line"> conn.<a class="code" href="classproton_1_1connection.html#af1fb4d28f91a33fb7c8a73a4083f6745">open_receiver</a>(url.<a class="code" href="classproton_1_1url.html#a9b67b266207227062c7a2961ef85293a">path</a>());</div>
-<div class="line"> conn.<a class="code" href="classproton_1_1connection.html#a7ebd6d1b79102078ccdb1e07b1cd90f7">open_sender</a>(url.<a class="code" href="classproton_1_1url.html#a9b67b266207227062c7a2961ef85293a">path</a>());</div>
-<div class="line"> }</div>
+<p><div class="fragment"><div class="line">}</div>
</div><!-- fragment --></p>
<p><code>on_sendable()</code> is called when message can be transferred over the associated sender link to the remote peer. We create a <code><a class="el" href="classproton_1_1message.html" title="An AMQP message. ">proton::message</a></code>, set the message body to <code>"Hello World!"</code> and send the message. Then we close the sender as we only want to send one message. Closing the sender will prevent further calls to <code>on_sendable()</code>.</p>
-<p><div class="fragment"><div class="line"> <span class="keywordtype">void</span> on_sendable(<a class="code" href="classproton_1_1event.html">proton::event</a> &e) {</div>
-<div class="line"> <a class="code" href="classproton_1_1message.html">proton::message</a> m(<span class="stringliteral">"Hello World!"</span>);</div>
-<div class="line"> e.<a class="code" href="classproton_1_1event.html#a68e6d2d54f8b0615c4e792c2bd4bb2c8">sender</a>().<a class="code" href="classproton_1_1sender.html#aefaf5ace497245ca76c6c9d629ae7bee">send</a>(m);</div>
-<div class="line"> e.<a class="code" href="classproton_1_1event.html#a68e6d2d54f8b0615c4e792c2bd4bb2c8">sender</a>().<a class="code" href="classproton_1_1link.html#a5ae591df94fc66ccb85cbb6565368bca">close</a>();</div>
-<div class="line"> }</div>
-</div><!-- fragment --></p>
+<p><div class="fragment"></div><!-- fragment --></p>
<p><code>on_message()</code> is called when a message is received. We just print the body of the message and close the connection, as we only want one message</p>
-<p><div class="fragment"><div class="line"> <span class="keywordtype">void</span> on_message(<a class="code" href="classproton_1_1event.html">proton::event</a> &e) {</div>
-<div class="line"> std::cout << e.<a class="code" href="classproton_1_1event.html#a05e07a1a99eaa74c1a3288511b15cae5">message</a>().<a class="code" href="classproton_1_1message.html#ae9af642f154a68ec0eb8e715ecaf95ae">body</a>() << std::endl;</div>
-<div class="line"> e.<a class="code" href="classproton_1_1event.html#a89bfeade377f12d843e51d16c353a556">connection</a>().<a class="code" href="classproton_1_1connection.html#a5ae591df94fc66ccb85cbb6565368bca">close</a>();</div>
-<div class="line"> }</div>
-</div><!-- fragment --></p>
-<p>The message body is a <code><a class="el" href="classproton_1_1value.html" title="A holder for any single AMQP value, simple or complex (can be list, array, map etc.) ">proton::value</a></code>, see the documentation for more on how to extract the message body as type-safe C++ values.</p>
+<p><div class="fragment"></div><!-- fragment --></p>
+<p>The message body is a <code><a class="el" href="classproton_1_1value.html" title="A holder for any AMQP value, simple or complex, see AMQP and C++ types. ">proton::value</a></code>, see the documentation for more on how to extract the message body as type-safe C++ values.</p>
<p>Our <code>main</code> function creates an instance of the <code>hello_world</code> handler and a <a class="el" href="classproton_1_1container.html" title="A top-level container of connections, sessions, and links. ">proton::container</a> using that handler. Calling <code><a class="el" href="classproton_1_1container.html#a13a43e6d814de94978c515cb084873b1" title="Start processing events. ">proton::container::run</a></code> sets things in motion and returns when we close the connection as there is nothing further to do. It may throw an exception, which will be a subclass of <code><a class="el" href="structproton_1_1error.html" title="The base proton error. ">proton::error</a></code>. That in turn is a subclass of <code>std::exception</code>.</p>
-<p><div class="fragment"><div class="line"><span class="keywordtype">int</span> main(<span class="keywordtype">int</span> argc, <span class="keywordtype">char</span> **argv) {</div>
-<div class="line"> <span class="keywordflow">try</span> {</div>
-<div class="line"> std::string url = argc > 1 ? argv[1] : <span class="stringliteral">"127.0.0.1:5672/examples"</span>;</div>
-<div class="line"></div>
-<div class="line"> hello_world hw(url);</div>
-<div class="line"> <a class="code" href="classproton_1_1container.html">proton::container</a>(hw).<a class="code" href="classproton_1_1container.html#a13a43e6d814de94978c515cb084873b1">run</a>();</div>
-<div class="line"> <span class="keywordflow">return</span> 0;</div>
-<div class="line"> } <span class="keywordflow">catch</span> (<span class="keyword">const</span> std::exception& e) {</div>
-<div class="line"> std::cerr << e.what() << std::endl;</div>
-<div class="line"> }</div>
-<div class="line"></div>
-<div class="line"> <span class="keywordflow">return</span> 1;</div>
-<div class="line">}</div>
-</div><!-- fragment --></p>
+<p><div class="fragment"></div><!-- fragment --></p>
<h2>Hello World, Direct! </h2>
<p>Though often used in conjunction with a broker, AMQP does not <em>require</em> this. It also allows senders and receivers to communicate directly if desired.</p>
-<p>We will modify our example to send a message directly to itself. This is a bit contrived but illustrates both sides of the direct send/receive scenario. Full code at <a class="el" href="helloworld_direct_8cpp-example.html">helloworld_direct.cpp</a></p>
+<p>We will modify our example to send a message directly to itself. This is a bit contrived but illustrates both sides of the direct send/receive scenario. Full code at helloworld_direct.cpp</p>
<p>The first difference, is that rather than creating a receiver on the same connection as our sender, we listen for incoming connections by invoking the <code><a class="el" href="classproton_1_1container.html#ab5a976cc459568f13da407a038591ca2" title="Listen on url for incoming connections. ">proton::container::listen()</a></code> method on the container.</p>
-<p><div class="fragment"><div class="line"> <span class="keywordtype">void</span> on_start(<a class="code" href="classproton_1_1event.html">proton::event</a> &e) {</div>
-<div class="line"> acceptor = e.<a class="code" href="classproton_1_1event.html#a0696f6baa06a440a8c298d3d1fdde0b9">container</a>().<a class="code" href="classproton_1_1container.html#ab5a976cc459568f13da407a038591ca2">listen</a>(url);</div>
-<div class="line"> e.<a class="code" href="classproton_1_1event.html#a0696f6baa06a440a8c298d3d1fdde0b9">container</a>().<a class="code" href="classproton_1_1container.html#ae8a3a769f9c424c05993f6d137376c76">open_sender</a>(url);</div>
-<div class="line"> }</div>
+<p><div class="fragment"><div class="line">}</div>
</div><!-- fragment --></p>
<p>As we only need then to initiate one link, the sender, we can do that by passing in a url rather than an existing connection, and the connection will also be automatically established for us.</p>
<p>We send the message in response to the <code>on_sendable()</code> callback and print the message out in response to the <code>on_message()</code> callback exactly as before.</p>
-<p><div class="fragment"><div class="line"> <span class="keywordtype">void</span> on_sendable(<a class="code" href="classproton_1_1event.html">proton::event</a> &e) {</div>
-<div class="line"> <a class="code" href="classproton_1_1message.html">proton::message</a> m(<span class="stringliteral">"Hello World!"</span>);</div>
-<div class="line"> e.<a class="code" href="classproton_1_1event.html#a68e6d2d54f8b0615c4e792c2bd4bb2c8">sender</a>().<a class="code" href="classproton_1_1sender.html#aefaf5ace497245ca76c6c9d629ae7bee">send</a>(m);</div>
-<div class="line"> e.<a class="code" href="classproton_1_1event.html#a68e6d2d54f8b0615c4e792c2bd4bb2c8">sender</a>().<a class="code" href="classproton_1_1link.html#a5ae591df94fc66ccb85cbb6565368bca">close</a>();</div>
-<div class="line"> }</div>
-<div class="line"></div>
-<div class="line"> <span class="keywordtype">void</span> on_message(<a class="code" href="classproton_1_1event.html">proton::event</a> &e) {</div>
-<div class="line"> std::cout << e.<a class="code" href="classproton_1_1event.html#a05e07a1a99eaa74c1a3288511b15cae5">message</a>().<a class="code" href="classproton_1_1message.html#ae9af642f154a68ec0eb8e715ecaf95ae">body</a>() << std::endl;</div>
-<div class="line"> }</div>
-</div><!-- fragment --></p>
+<p><div class="fragment"></div><!-- fragment --></p>
<p>However we also handle two new events. We now close the connection from the senders side once the message has been accepted. The acceptance of the message is an indication of successful transfer to the peer. We are notified of that event through the <code>on_delivery_accept()</code> callback.</p>
-<p><div class="fragment"><div class="line"> <span class="keywordtype">void</span> on_delivery_accept(<a class="code" href="classproton_1_1event.html">proton::event</a> &e) {</div>
-<div class="line"> e.<a class="code" href="classproton_1_1event.html#a89bfeade377f12d843e51d16c353a556">connection</a>().<a class="code" href="classproton_1_1connection.html#a5ae591df94fc66ccb85cbb6565368bca">close</a>();</div>
-<div class="line"> }</div>
-</div><!-- fragment --></p>
+<p><div class="fragment"></div><!-- fragment --></p>
<p>Then, once the connection has been closed, of which we are notified through the <code>on_connection_close()</code> callback, we stop accepting incoming connections at which point there is no work to be done and the event loop exits, and the run() method will return.</p>
-<p><div class="fragment"><div class="line"> <span class="keywordtype">void</span> on_connection_close(<a class="code" href="classproton_1_1event.html">proton::event</a> &e) {</div>
-<div class="line"> acceptor.close();</div>
-<div class="line"> }</div>
-</div><!-- fragment --></p>
+<p><div class="fragment"></div><!-- fragment --></p>
<p>So now we have our example working without a broker involved!</p>
<p>Note that for this example we pick an "unusual" port 8888 since we are talking to ourselves rather than a broker.</p>
-<p><div class="fragment"><div class="line"> std::string url = argc > 1 ? argv[1] : <span class="stringliteral">"127.0.0.1:8888/examples"</span>;</div>
-</div><!-- fragment --></p>
+<p><div class="fragment"></div><!-- fragment --></p>
<h2>Asynchronous Send and Receive </h2>
<p>Of course, these <code>HelloWorld!</code> examples are very artificial, communicating as they do over a network connection but with the same process. A more realistic example involves communication between separate processes (which could indeed be running on completely separate machines).</p>
<p>Let's separate the sender from the receiver, and transfer more than a single message between them.</p>
-<p>We'll start with a simple sender <a class="el" href="simple_send_8cpp-example.html">simple_send.cpp</a>.</p>
+<p>We'll start with a simple sender simple_send.cpp.</p>
<p>As with the previous example, we define the application logic in a class that handles events. Because we are transferring more than one message, we need to keep track of how many we have sent. We'll use a <code>sent</code> member variable for that. The <code>total</code> member variable will hold the number of messages we want to send.</p>
<p><div class="fragment"><div class="line"><span class="keyword">class </span>simple_send : <span class="keyword">public</span> <a class="code" href="classproton_1_1handler.html">proton::handler</a> {</div>
<div class="line"> <span class="keyword">private</span>:</div>
@@ -201,42 +155,16 @@ $(document).ready(function(){initNavTree
<div class="line"> <span class="keywordtype">int</span> total;</div>
</div><!-- fragment --></p>
<p>As before, we use the <code>on_start()</code> event to establish our sender link over which we will transfer messages.</p>
-<p><div class="fragment"><div class="line"> <span class="keywordtype">void</span> on_start(<a class="code" href="classproton_1_1event.html">proton::event</a> &e) {</div>
-<div class="line"> sender = e.<a class="code" href="classproton_1_1event.html#a0696f6baa06a440a8c298d3d1fdde0b9">container</a>().<a class="code" href="classproton_1_1container.html#ae8a3a769f9c424c05993f6d137376c76">open_sender</a>(url);</div>
-<div class="line"> }</div>
+<p><div class="fragment"><div class="line">}</div>
</div><!-- fragment --></p>
<p>AMQP defines a credit-based flow control mechanism. Flow control allows the receiver to control how many messages it is prepared to receive at a given time and thus prevents any component being overwhelmed by the number of messages it is sent.</p>
<p>In the <code>on_sendable()</code> callback, we check that our sender has credit before sending messages. We also check that we haven't already sent the required number of messages.</p>
-<p><div class="fragment"><div class="line"> <span class="keywordtype">void</span> on_sendable(<a class="code" href="classproton_1_1event.html">proton::event</a> &e) {</div>
-<div class="line"> <a class="code" href="classproton_1_1sender.html">proton::sender</a> sender = e.<a class="code" href="classproton_1_1event.html#a68e6d2d54f8b0615c4e792c2bd4bb2c8">sender</a>();</div>
-<div class="line"> </div>
-<div class="line"> <span class="keywordflow">while</span> (sender.<a class="code" href="classproton_1_1link.html#a75360c7515b9f569871c5ea953286649">credit</a>() && sent < total) {</div>
-<div class="line"> <a class="code" href="classproton_1_1message.html">proton::message</a> msg;</div>
-<div class="line"> std::map<std::string, int> m;</div>
-<div class="line"> m[<span class="stringliteral">"sequence"</span>] = sent + 1;</div>
-<div class="line"> </div>
-<div class="line"> msg.id(sent + 1);</div>
-<div class="line"> msg.<a class="code" href="classproton_1_1message.html#ae9af642f154a68ec0eb8e715ecaf95ae">body</a>(m);</div>
-<div class="line"></div>
-<div class="line"> sender.<a class="code" href="classproton_1_1sender.html#aefaf5ace497245ca76c6c9d629ae7bee">send</a>(msg);</div>
-<div class="line"> sent++;</div>
-<div class="line"> }</div>
-<div class="line"> }</div>
-</div><!-- fragment --></p>
+<p><div class="fragment"></div><!-- fragment --></p>
<p>The <code><a class="el" href="classproton_1_1sender.html#aefaf5ace497245ca76c6c9d629ae7bee" title="Send a message on the link. ">proton::sender::send()</a></code> call above is asynchronous. When it returns the message has not yet actually been transferred across the network to the receiver. By handling the <code>on_accepted()</code> event, we can get notified when the receiver has received and accepted the message. In our example we use this event to track the confirmation of the messages we have sent. We only close the connection and exit when the receiver has received all the messages we wanted to send.</p>
-<p><div class="fragment"><div class="line"> <span class="keywordtype">void</span> on_delivery_accept(<a class="code" href="classproton_1_1event.html">proton::event</a> &e) {</div>
-<div class="line"> confirmed++;</div>
-<div class="line"> </div>
-<div class="line"> <span class="keywordflow">if</span> (confirmed == total) {</div>
-<div class="line"> std::cout << <span class="stringliteral">"all messages confirmed"</span> << std::endl;</div>
-<div class="line"> e.<a class="code" href="classproton_1_1event.html#a89bfeade377f12d843e51d16c353a556">connection</a>().<a class="code" href="classproton_1_1connection.html#a5ae591df94fc66ccb85cbb6565368bca">close</a>();</div>
-<div class="line"> }</div>
-<div class="line"> }</div>
-</div><!-- fragment --></p>
+<p><div class="fragment"></div><!-- fragment --></p>
<p>If we are disconnected after a message is sent and before it has been confirmed by the receiver, it is said to be <code>in doubt</code>. We don't know whether or not it was received. In this example, we will handle that by resending any in-doubt messages. This is known as an 'at-least-once' guarantee, since each message should eventually be received at least once, though a given message may be received more than once (i.e. duplicates are possible). In the <code>on_disconnected()</code> callback, we reset the sent count to reflect only those that have been confirmed. The library will automatically try to reconnect for us, and when our sender is sendable again, we can restart from the point we know the receiver got to.</p>
-<p><div class="fragment"><div class="line">}</div>
-</div><!-- fragment --></p>
-<p>Now let's look at the corresponding receiver <a class="el" href="simple_recv_8cpp-example.html">simple_recv.cpp</a></p>
+<p><div class="fragment"></div><!-- fragment --></p>
+<p>Now let's look at the corresponding receiver simple_recv.cpp</p>
<p>This time we'll use an <code>expected</code> member variable for for the number of messages we expect and a <code>received</code> variable to count how many we have received so far.</p>
<p><div class="fragment"><div class="line"><span class="keyword">class </span>simple_recv : <span class="keyword">public</span> <a class="code" href="classproton_1_1handler.html">proton::handler</a> {</div>
<div class="line"> <span class="keyword">private</span>:</div>
@@ -246,72 +174,28 @@ $(document).ready(function(){initNavTree
<div class="line"> uint64_t received;</div>
</div><!-- fragment --></p>
<p>We handle <code>on_start()</code> by creating our receiver, much like we did for the sender.</p>
-<p><div class="fragment"><div class="line"> <span class="keywordtype">void</span> on_start(<a class="code" href="classproton_1_1event.html">proton::event</a> &e) {</div>
-<div class="line"> receiver = e.<a class="code" href="classproton_1_1event.html#a0696f6baa06a440a8c298d3d1fdde0b9">container</a>().<a class="code" href="classproton_1_1container.html#a9d15beec9803fa359017bb6263cef249">open_receiver</a>(url);</div>
-<div class="line"> std::cout << <span class="stringliteral">"simple_recv listening on "</span> << url << std::endl;</div>
-<div class="line"> }</div>
+<p><div class="fragment"><div class="line">}</div>
</div><!-- fragment --></p>
<p>We also handle the <code>on_message()</code> event for received messages and print the message out as in the <code>Hello World!</code> examples. However we add some logic to allow the receiver to wait for a given number of messages, then to close the connection and exit. We also add some logic to check for and ignore duplicates, using a simple sequential id scheme.</p>
-<p><div class="fragment"><div class="line"> <span class="keywordtype">void</span> on_message(<a class="code" href="classproton_1_1event.html">proton::event</a> &e) {</div>
-<div class="line"> <a class="code" href="classproton_1_1message.html">proton::message</a>& msg = e.<a class="code" href="classproton_1_1event.html#a05e07a1a99eaa74c1a3288511b15cae5">message</a>();</div>
-<div class="line"> </div>
-<div class="line"> <span class="keywordflow">if</span> (msg.id().get<uint64_t>() < received) {</div>
-<div class="line"> <span class="keywordflow">return</span>; <span class="comment">// Ignore duplicate</span></div>
-<div class="line"> }</div>
-</div><!-- fragment --></p>
+<p><div class="fragment"></div><!-- fragment --></p>
<h2>Direct Send and Receive </h2>
-<p>Sending between these two examples requires an intermediary broker since neither accepts incoming connections. AMQP allows us to send messages directly between two processes. In that case one or other of the processes needs to accept incoming connections. Let's create a modified version of the receiving example that does this with <a class="el" href="direct_recv_8cpp-example.html">direct_recv.cpp</a></p>
+<p>Sending between these two examples requires an intermediary broker since neither accepts incoming connections. AMQP allows us to send messages directly between two processes. In that case one or other of the processes needs to accept incoming connections. Let's create a modified version of the receiving example that does this with direct_recv.cpp</p>
<p>There are only two differences here. Instead of initiating a link (and implicitly a connection), we listen for incoming connections.</p>
-<p><div class="fragment"><div class="line"> <span class="keywordtype">void</span> on_start(<a class="code" href="classproton_1_1event.html">proton::event</a> &e) {</div>
-<div class="line"> acceptor = e.<a class="code" href="classproton_1_1event.html#a0696f6baa06a440a8c298d3d1fdde0b9">container</a>().<a class="code" href="classproton_1_1container.html#ab5a976cc459568f13da407a038591ca2">listen</a>(url);</div>
-<div class="line"> std::cout << <span class="stringliteral">"direct_recv listening on "</span> << url << std::endl;</div>
-<div class="line"> }</div>
+<p><div class="fragment"><div class="line">}</div>
</div><!-- fragment --></p>
<p>When we have received all the expected messages, we then stop listening for incoming connections by closing the acceptor object.</p>
-<p><div class="fragment"><div class="line"> <span class="keywordtype">void</span> on_message(<a class="code" href="classproton_1_1event.html">proton::event</a> &e) {</div>
-<div class="line"> <a class="code" href="classproton_1_1message.html">proton::message</a>& msg = e.<a class="code" href="classproton_1_1event.html#a05e07a1a99eaa74c1a3288511b15cae5">message</a>();</div>
-<div class="line"> </div>
-<div class="line"> <span class="keywordflow">if</span> (msg.id().get<uint64_t>() < received) {</div>
-<div class="line"> <span class="keywordflow">return</span>; <span class="comment">// Ignore duplicate</span></div>
-<div class="line"> }</div>
-<div class="line"> </div>
-<div class="line"> <span class="keywordflow">if</span> (expected == 0 || received < expected) {</div>
-<div class="line"> std::cout << msg.<a class="code" href="classproton_1_1message.html#ae9af642f154a68ec0eb8e715ecaf95ae">body</a>() << std::endl;</div>
-<div class="line"> received++;</div>
-<div class="line"> }</div>
-<div class="line"> </div>
-<div class="line"> <span class="keywordflow">if</span> (received == expected) {</div>
-<div class="line"> e.<a class="code" href="classproton_1_1event.html#a7addccdd75bcff734183d97f241795cf">receiver</a>().<a class="code" href="classproton_1_1link.html#a5ae591df94fc66ccb85cbb6565368bca">close</a>();</div>
-<div class="line"> e.<a class="code" href="classproton_1_1event.html#a89bfeade377f12d843e51d16c353a556">connection</a>().<a class="code" href="classproton_1_1connection.html#a5ae591df94fc66ccb85cbb6565368bca">close</a>();</div>
-<div class="line"></div>
-<div class="line"> <span class="keywordflow">if</span> (!!acceptor) acceptor.close();</div>
-<div class="line"> }</div>
-<div class="line"> }</div>
-</div><!-- fragment --></p>
-<p>You can use the <a class="el" href="simple_send_8cpp-example.html">simple_send.cpp</a> example to send to this receiver directly. (Note: you will need to stop any broker that is listening on the 5672 port, or else change the port used by specifying a different address to each example via the -a command line switch).</p>
-<p>We can also modify the sender to allow the original receiver to connect to it, in <a class="el" href="direct_send_8cpp-example.html">direct_send.cpp</a>. Again that just requires two modifications:</p>
+<p><div class="fragment"></div><!-- fragment --></p>
+<p>You can use the simple_send.cpp example to send to this receiver directly. (Note: you will need to stop any broker that is listening on the 5672 port, or else change the port used by specifying a different address to each example via the -a command line switch).</p>
+<p>We can also modify the sender to allow the original receiver to connect to it, in direct_send.cpp. Again that just requires two modifications:</p>
<p>As with the modified receiver, instead of initiating establishment of a link, we listen for incoming connections.</p>
-<p><div class="fragment"><div class="line"> <span class="keywordtype">void</span> on_start(<a class="code" href="classproton_1_1event.html">proton::event</a> &e) {</div>
-<div class="line"> acceptor = e.<a class="code" href="classproton_1_1event.html#a0696f6baa06a440a8c298d3d1fdde0b9">container</a>().<a class="code" href="classproton_1_1container.html#ab5a976cc459568f13da407a038591ca2">listen</a>(url);</div>
-<div class="line"> std::cout << <span class="stringliteral">"direct_send listening on "</span> << url << std::endl;</div>
-<div class="line"> }</div>
+<p><div class="fragment"><div class="line">}</div>
</div><!-- fragment --></p>
<p>When we have received confirmation of all the messages we sent, we can close the acceptor in order to exit.</p>
-<p><div class="fragment"><div class="line"> <span class="keywordtype">void</span> on_delivery_accept(<a class="code" href="classproton_1_1event.html">proton::event</a> &e) {</div>
-<div class="line"> confirmed++;</div>
-<div class="line"></div>
-<div class="line"> <span class="keywordflow">if</span> (confirmed == total) {</div>
-<div class="line"> std::cout << <span class="stringliteral">"all messages confirmed"</span> << std::endl;</div>
-<div class="line"></div>
-<div class="line"> e.<a class="code" href="classproton_1_1event.html#a89bfeade377f12d843e51d16c353a556">connection</a>().<a class="code" href="classproton_1_1connection.html#a5ae591df94fc66ccb85cbb6565368bca">close</a>();</div>
-<div class="line"> acceptor.close();</div>
-<div class="line"> }</div>
-<div class="line"> }</div>
-</div><!-- fragment --></p>
-<p>To try this modified sender, run the original <a class="el" href="simple_recv_8cpp-example.html">simple_recv.cpp</a> against it.</p>
-<p>The symmetry in the underlying AMQP that enables this is quite unique and elegant, and in reflecting this the proton API provides a flexible toolkit for implementing all sorts of interesting intermediaries (<a class="el" href="broker_8hpp-example.html">broker.hpp</a> and <a class="el" href="broker_8cpp-example.html">broker.cpp</a> provide a simple broker for testing purposes is an example of this).</p>
+<p><div class="fragment"></div><!-- fragment --></p>
+<p>To try this modified sender, run the original simple_recv.cpp against it.</p>
+<p>The symmetry in the underlying AMQP that enables this is quite unique and elegant, and in reflecting this the proton API provides a flexible toolkit for implementing all sorts of interesting intermediaries (broker.hpp and broker.cpp provide a simple broker for testing purposes is an example of this).</p>
<h2>Request/Response </h2>
-<p>A common pattern is to send a request message and expect a response message in return. AMQP has special support for this pattern. Let's have a look at a simple example. We'll start with <a class="el" href="server_8cpp-example.html">server.cpp</a>, the program that will process the request and send the response. Note that we are still using a broker in this example.</p>
+<p>A common pattern is to send a request message and expect a response message in return. AMQP has special support for this pattern. Let's have a look at a simple example. We'll start with server.cpp, the program that will process the request and send the response. Note that we are still using a broker in this example.</p>
<p>Our server will provide a very simple service: it will respond with the body of the request converted to uppercase.</p>
<div class="fragment"><div class="line"><span class="keyword">class </span>server : <span class="keyword">public</span> <a class="code" href="classproton_1_1handler.html">proton::handler</a> {</div>
<div class="line"> <span class="keyword">private</span>:</div>
@@ -323,8 +207,8 @@ $(document).ready(function(){initNavTree
<div class="line"> <span class="keyword">public</span>:</div>
<div class="line"> server(<span class="keyword">const</span> std::string &u) : url(u) {}</div>
<div class="line"></div>
-<div class="line"> <span class="keywordtype">void</span> <a class="code" href="classproton_1_1handler.html#a853f861e091fdb37b69d94be1b0ea032">on_start</a>(<a class="code" href="classproton_1_1event.html">proton::event</a> &e) {</div>
-<div class="line"> connection = e.<a class="code" href="classproton_1_1event.html#a0696f6baa06a440a8c298d3d1fdde0b9">container</a>().<a class="code" href="classproton_1_1container.html#a544f214bbb007ed7c2331cbebb60c283">connect</a>(url);</div>
+<div class="line"> <span class="keywordtype">void</span> <a class="code" href="classproton_1_1handler.html#a4949b0c93402fae0c07492d984688a25">on_container_start</a>(<a class="code" href="classproton_1_1container.html">proton::container</a> &c)<span class="keyword"> override </span>{</div>
+<div class="line"> connection = c.<a class="code" href="classproton_1_1container.html#a544f214bbb007ed7c2331cbebb60c283">connect</a>(url);</div>
<div class="line"> connection.<a class="code" href="classproton_1_1connection.html#af1fb4d28f91a33fb7c8a73a4083f6745">open_receiver</a>(url.<a class="code" href="classproton_1_1url.html#a9b67b266207227062c7a2961ef85293a">path</a>());</div>
<div class="line"></div>
<div class="line"> std::cout << <span class="stringliteral">"server connected to "</span> << url << std::endl;</div>
@@ -339,15 +223,15 @@ $(document).ready(function(){initNavTree
<div class="line"> <span class="keywordflow">return</span> uc;</div>
<div class="line"> }</div>
<div class="line"></div>
-<div class="line"> <span class="keywordtype">void</span> <a class="code" href="classproton_1_1handler.html#ade01b01951064667a5a076362c5e61ef">on_message</a>(<a class="code" href="classproton_1_1event.html">proton::event</a> &e) {</div>
-<div class="line"> std::cout << <span class="stringliteral">"Received "</span> << e.<a class="code" href="classproton_1_1event.html#a05e07a1a99eaa74c1a3288511b15cae5">message</a>().<a class="code" href="classproton_1_1message.html#ae9af642f154a68ec0eb8e715ecaf95ae">body</a>() << std::endl;</div>
+<div class="line"> <span class="keywordtype">void</span> <a class="code" href="classproton_1_1handler.html#a96879b0b0b7ade11f98d3f450abd4c46">on_message</a>(<a class="code" href="classproton_1_1delivery.html">proton::delivery</a> &d, <a class="code" href="classproton_1_1message.html">proton::message</a> &m)<span class="keyword"> override </span>{</div>
+<div class="line"> std::cout << <span class="stringliteral">"Received "</span> << m.<a class="code" href="classproton_1_1message.html#ae9af642f154a68ec0eb8e715ecaf95ae">body</a>() << std::endl;</div>
<div class="line"></div>
-<div class="line"> std::string reply_to = e.<a class="code" href="classproton_1_1event.html#a05e07a1a99eaa74c1a3288511b15cae5">message</a>().reply_to();</div>
+<div class="line"> std::string reply_to = m.reply_to();</div>
<div class="line"> <a class="code" href="classproton_1_1message.html">proton::message</a> reply;</div>
<div class="line"></div>
<div class="line"> reply.address(reply_to);</div>
-<div class="line"> reply.<a class="code" href="classproton_1_1message.html#ae9af642f154a68ec0eb8e715ecaf95ae">body</a>(to_upper(e.<a class="code" href="classproton_1_1event.html#a05e07a1a99eaa74c1a3288511b15cae5">message</a>().<a class="code" href="classproton_1_1message.html#ae9af642f154a68ec0eb8e715ecaf95ae">body</a>().get<std::string>()));</div>
-<div class="line"> reply.correlation_id(e.<a class="code" href="classproton_1_1event.html#a05e07a1a99eaa74c1a3288511b15cae5">message</a>().correlation_id());</div>
+<div class="line"> reply.<a class="code" href="classproton_1_1message.html#ae9af642f154a68ec0eb8e715ecaf95ae">body</a>(to_upper(proton::get<std::string>(m.<a class="code" href="classproton_1_1message.html#ae9af642f154a68ec0eb8e715ecaf95ae">body</a>())));</div>
+<div class="line"> reply.correlation_id(m.correlation_id());</div>
<div class="line"></div>
<div class="line"> <span class="keywordflow">if</span> (!senders[reply_to]) {</div>
<div class="line"> senders[reply_to] = connection.<a class="code" href="classproton_1_1connection.html#a7ebd6d1b79102078ccdb1e07b1cd90f7">open_sender</a>(reply_to);</div>
@@ -358,50 +242,21 @@ $(document).ready(function(){initNavTree
<div class="line">};</div>
</div><!-- fragment --></p>
<p>The code here is not too different from the simple receiver example. When we receive a request in <code>on_message</code> however, we look at the <code>proton::message::reply_to</code> address and create a sender with that address for the response. We'll cache the senders incase we get further requests with the same <code>reply_to</code>.</p>
-<p>Now let's create a simple <a class="el" href="client_8cpp-example.html">client.cpp</a> to test this service out.</p>
+<p>Now let's create a simple client.cpp to test this service out.</p>
<p>Our client takes a list of strings to send as requests</p>
<p><div class="fragment"><div class="line"> client(<span class="keyword">const</span> <a class="code" href="classproton_1_1url.html">proton::url</a> &u, <span class="keyword">const</span> std::vector<std::string>& r) : url(u), requests(r) {}</div>
</div><!-- fragment --></p>
<p>Since we will be sending and receiving, we create a sender and a receiver in <code>on_start</code>. Our receiver has a blank address and sets the <code>dynamic</code> flag to true, which means we expect the remote end (broker or server) to assign a unique address for us.</p>
-<p><div class="fragment"><div class="line"> <span class="keywordtype">void</span> on_start(<a class="code" href="classproton_1_1event.html">proton::event</a> &e) {</div>
-<div class="line"> sender = e.<a class="code" href="classproton_1_1event.html#a0696f6baa06a440a8c298d3d1fdde0b9">container</a>().<a class="code" href="classproton_1_1container.html#ae8a3a769f9c424c05993f6d137376c76">open_sender</a>(url);</div>
-<div class="line"> <span class="comment">// Create a receiver with a dynamically chosen unique address.</span></div>
-<div class="line"> receiver = sender.<a class="code" href="classproton_1_1link.html#af13d10fc3d843719af9ff4c456330a73">connection</a>().<a class="code" href="classproton_1_1connection.html#af1fb4d28f91a33fb7c8a73a4083f6745">open_receiver</a>(<span class="stringliteral">""</span>, <a class="code" href="classproton_1_1link__options.html">proton::link_options</a>().dynamic_address(<span class="keyword">true</span>));</div>
-<div class="line"> }</div>
+<p><div class="fragment"><div class="line">}</div>
</div><!-- fragment --></p>
<p>Now a function to send the next request from our list of requests. We set the reply_to address to be the dynamically assigned address of our receiver.</p>
-<p><div class="fragment"><div class="line"> <span class="keywordtype">void</span> send_request() {</div>
-<div class="line"> <a class="code" href="classproton_1_1message.html">proton::message</a> req;</div>
-<div class="line"> req.<a class="code" href="classproton_1_1message.html#ae9af642f154a68ec0eb8e715ecaf95ae">body</a>(requests.front());</div>
-<div class="line"> req.reply_to(receiver.<a class="code" href="classproton_1_1link.html#adc8d612ee69e5722919c1bc2c95df66e">remote_source</a>().<a class="code" href="classproton_1_1terminus.html#a977efa04715923ca4fa290a6ec90c830">address</a>());</div>
-<div class="line"></div>
-<div class="line"> sender.<a class="code" href="classproton_1_1sender.html#aefaf5ace497245ca76c6c9d629ae7bee">send</a>(req);</div>
-<div class="line"> }</div>
-</div><!-- fragment --></p>
+<p><div class="fragment"></div><!-- fragment --></p>
<p>We need to use the address assigned by the broker as the <code>reply_to</code> address of our requests, so we can't send them until our receiver has been set up. To do that, we add an <code>on_link_open()</code> method to our handler class, and if the link associated with event is the receiver, we use that as the trigger to send our first request.</p>
-<p><div class="fragment"><div class="line"> <span class="keywordtype">void</span> on_link_open(<a class="code" href="classproton_1_1event.html">proton::event</a> &e) {</div>
-<div class="line"> <span class="keywordflow">if</span> (e.<a class="code" href="classproton_1_1event.html#a2ce4835ffc5538deb4004da365e8be57">link</a>() == receiver) {</div>
-<div class="line"> send_request();</div>
-<div class="line"> }</div>
-</div><!-- fragment --></p>
+<p><div class="fragment"></div><!-- fragment --></p>
<p>When we receive a reply, we send the next request.</p>
-<p><div class="fragment"><div class="line"> <span class="keywordtype">void</span> on_message(<a class="code" href="classproton_1_1event.html">proton::event</a> &e) {</div>
-<div class="line"> <span class="keywordflow">if</span> (requests.empty()) <span class="keywordflow">return</span>; <span class="comment">// Spurious extra message!</span></div>
-<div class="line"></div>
-<div class="line"> <a class="code" href="classproton_1_1message.html">proton::message</a>& response = e.<a class="code" href="classproton_1_1event.html#a05e07a1a99eaa74c1a3288511b15cae5">message</a>();</div>
-<div class="line"></div>
-<div class="line"> std::cout << requests.front() << <span class="stringliteral">" => "</span> << response.<a class="code" href="classproton_1_1message.html#ae9af642f154a68ec0eb8e715ecaf95ae">body</a>() << std::endl;</div>
-<div class="line"> requests.erase(requests.begin());</div>
-<div class="line"></div>
-<div class="line"> <span class="keywordflow">if</span> (!requests.empty()) {</div>
-<div class="line"> send_request();</div>
-<div class="line"> } <span class="keywordflow">else</span> {</div>
-<div class="line"> e.<a class="code" href="classproton_1_1event.html#a89bfeade377f12d843e51d16c353a556">connection</a>().<a class="code" href="classproton_1_1connection.html#a5ae591df94fc66ccb85cbb6565368bca">close</a>();</div>
-<div class="line"> }</div>
-<div class="line"> }</div>
-</div><!-- fragment --></p>
+<p><div class="fragment"></div><!-- fragment --></p>
<h2>Direct Request/Response </h2>
-<p>We can avoid the intermediary process by writing a server that accepts connections directly, <a class="el" href="server_direct_8cpp-example.html">server_direct.cpp</a>. It involves the following changes to our original server:</p>
+<p>We can avoid the intermediary process by writing a server that accepts connections directly, server_direct.cpp. It involves the following changes to our original server:</p>
<p>Our server must generate a unique reply-to addresses for links from the client that request a dynamic address (previously this was done by the broker.) We use a simple counter.</p>
<p><div class="fragment"><div class="line"> std::string generate_address() {</div>
<div class="line"> std::ostringstream addr;</div>
@@ -411,64 +266,20 @@ $(document).ready(function(){initNavTree
<div class="line"> }</div>
</div><!-- fragment --></p>
<p>Next we need to handle incoming requests for links with dynamic addresses from the client. We give the link a unique address and record it in our <code>senders</code> map.</p>
-<p><div class="fragment"><div class="line"> <span class="keywordtype">void</span> on_link_open(<a class="code" href="classproton_1_1event.html">proton::event</a>& e) {</div>
-<div class="line"> <a class="code" href="classproton_1_1link.html">proton::link</a> link = e.<a class="code" href="classproton_1_1event.html#a2ce4835ffc5538deb4004da365e8be57">link</a>();</div>
-<div class="line"> </div>
-<div class="line"> <span class="keywordflow">if</span> (!!link.sender() && link.<a class="code" href="classproton_1_1link.html#adc8d612ee69e5722919c1bc2c95df66e">remote_source</a>().<a class="code" href="classproton_1_1terminus.html#ab6f99d305cf67c3a6c3d786d2b819ca8">dynamic</a>()) {</div>
-<div class="line"> link.<a class="code" href="classproton_1_1link.html#a2246ba119cbaa626fb423e1ba80f84c5">local_source</a>().<a class="code" href="classproton_1_1terminus.html#a977efa04715923ca4fa290a6ec90c830">address</a>(generate_address());</div>
-<div class="line"> senders[link.<a class="code" href="classproton_1_1link.html#a2246ba119cbaa626fb423e1ba80f84c5">local_source</a>().<a class="code" href="classproton_1_1terminus.html#a977efa04715923ca4fa290a6ec90c830">address</a>()] = link.sender();</div>
-<div class="line"> }</div>
+<p><div class="fragment"><div class="line">}</div>
</div><!-- fragment --></p>
<p>Note we are interested in <em>sender</em> links above because we are implementing the server. A <em>receiver</em> link created on the client corresponds to a <em>sender</em> link on the server.</p>
<p>Finally when we receive a message we look up its <code>reply_to</code> in our senders map and send the reply.</p>
-<p><div class="fragment"><div class="line"> <span class="keywordtype">void</span> on_message(<a class="code" href="classproton_1_1event.html">proton::event</a> &e) {</div>
-<div class="line"> std::cout << <span class="stringliteral">"Received "</span> << e.<a class="code" href="classproton_1_1event.html#a05e07a1a99eaa74c1a3288511b15cae5">message</a>().<a class="code" href="classproton_1_1message.html#ae9af642f154a68ec0eb8e715ecaf95ae">body</a>() << std::endl;</div>
-<div class="line"> </div>
-<div class="line"> std::string reply_to = e.<a class="code" href="classproton_1_1event.html#a05e07a1a99eaa74c1a3288511b15cae5">message</a>().reply_to();</div>
-<div class="line"> sender_map::iterator it = senders.find(reply_to);</div>
-<div class="line"> </div>
-<div class="line"> <span class="keywordflow">if</span> (it == senders.end()) {</div>
-<div class="line"> std::cout << <span class="stringliteral">"No link for reply_to: "</span> << reply_to << std::endl;</div>
-<div class="line"> } <span class="keywordflow">else</span> {</div>
-<div class="line"> <a class="code" href="classproton_1_1sender.html">proton::sender</a> sender = it->second;</div>
-<div class="line"> <a class="code" href="classproton_1_1message.html">proton::message</a> reply;</div>
-<div class="line"> </div>
-<div class="line"> reply.address(reply_to);</div>
-<div class="line"> reply.<a class="code" href="classproton_1_1message.html#ae9af642f154a68ec0eb8e715ecaf95ae">body</a>(to_upper(e.<a class="code" href="classproton_1_1event.html#a05e07a1a99eaa74c1a3288511b15cae5">message</a>().<a class="code" href="classproton_1_1message.html#ae9af642f154a68ec0eb8e715ecaf95ae">body</a>().get<std::string>()));</div>
-<div class="line"> reply.correlation_id(e.<a class="code" href="classproton_1_1event.html#a05e07a1a99eaa74c1a3288511b15cae5">message</a>().correlation_id());</div>
-<div class="line"></div>
-<div class="line"> sender.<a class="code" href="classproton_1_1sender.html#aefaf5ace497245ca76c6c9d629ae7bee">send</a>(reply);</div>
-<div class="line"> }</div>
-<div class="line"> }</div>
-</div><!-- fragment --></p>
+<p><div class="fragment"></div><!-- fragment --></p>
<h2>Connection Engine </h2>
-<p>The <code><a class="el" href="classproton_1_1connection__engine.html" title="An interface for connection-oriented IO integration. ">proton::connection_engine</a></code> is an alternative to the container. For simple applications with a single connection, its use is about the same as the the <code><a class="el" href="classproton_1_1container.html" title="A top-level container of connections, sessions, and links. ">proton::container</a></code>, but it allows more flexibility for multi-threaded applications or applications with unusual IO requirements.</p>
-<p>We'll look at the <a class="el" href="engine_2helloworld_8cpp-example.html">engine/helloworld.cpp</a> example step-by-step to see how it differs from the container <a class="el" href="helloworld_8cpp-example.html">helloworld.cpp</a> version.</p>
-<p>First we include the <code><a class="el" href="classproton_1_1io_1_1socket__engine.html" title="A connection_engine for socket-based IO. ">proton::io::socket_engine</a></code> class, which is a <code><a class="el" href="classproton_1_1connection__engine.html" title="An interface for connection-oriented IO integration. ">proton::connection_engine</a></code> that uses socket IO.</p>
-<p><div class="fragment"><div class="line"><span class="preprocessor">#include "proton/io.hpp"</span></div>
-</div><!-- fragment --></p>
+<p>The <code>proton::connection_engine</code> is an alternative to the container. For simple applications with a single connection, its use is about the same as the the <code><a class="el" href="classproton_1_1container.html" title="A top-level container of connections, sessions, and links. ">proton::container</a></code>, but it allows more flexibility for multi-threaded applications or applications with unusual IO requirements.</p>
+<p>We'll look at the engine/helloworld.cpp example step-by-step to see how it differs from the container helloworld.cpp version.</p>
+<p>First we include the <code><a class="el" href="classproton_1_1io_1_1socket_1_1engine.html" title="A connection_engine with non-blocking socket IO. ">proton::io::socket::engine</a></code> class, which is a <code>proton::connection_engine</code> that uses socket IO.</p>
+<p><div class="fragment"></div><!-- fragment --></p>
<p>Our <code>hello_world</code> class differs only in the <code>on_start()</code> method. Instead of calling <code>container.connect()</code>, we simply call <code>proton::connection::open</code> to open the engine's' connection:</p>
-<p><div class="fragment"><div class="line"> <span class="keywordtype">void</span> on_start(<a class="code" href="classproton_1_1event.html">proton::event</a> &e) {</div>
-<div class="line"> e.<a class="code" href="classproton_1_1event.html#a89bfeade377f12d843e51d16c353a556">connection</a>().open();</div>
-<div class="line"> e.<a class="code" href="classproton_1_1event.html#a89bfeade377f12d843e51d16c353a556">connection</a>().<a class="code" href="classproton_1_1connection.html#af1fb4d28f91a33fb7c8a73a4083f6745">open_receiver</a>(address_);</div>
-<div class="line"> e.<a class="code" href="classproton_1_1event.html#a89bfeade377f12d843e51d16c353a556">connection</a>().<a class="code" href="classproton_1_1connection.html#a7ebd6d1b79102078ccdb1e07b1cd90f7">open_sender</a>(address_);</div>
-<div class="line"> }</div>
-</div><!-- fragment --></p>
-<p>Our <code>main</code> function only differs in that it creates and runs a <code>socket_engine</code> instead of a <code>container</code>.</p>
-<p><div class="fragment"><div class="line"><span class="keywordtype">int</span> main(<span class="keywordtype">int</span> argc, <span class="keywordtype">char</span> **argv) {</div>
-<div class="line"> <span class="keywordflow">try</span> {</div>
-<div class="line"> <a class="code" href="classproton_1_1url.html">proton::url</a> url(argc > 1 ? argv[1] : <span class="stringliteral">"127.0.0.1:5672/examples"</span>);</div>
-<div class="line"> hello_world hw(url.<a class="code" href="classproton_1_1url.html#a9b67b266207227062c7a2961ef85293a">path</a>());</div>
-<div class="line"> <a class="code" href="classproton_1_1io_1_1socket__engine.html">proton::io::socket_engine</a>(url, hw).<a class="code" href="classproton_1_1io_1_1socket__engine.html#a13a43e6d814de94978c515cb084873b1">run</a>();</div>
-<div class="line"></div>
-<div class="line"> <span class="keywordflow">return</span> 0;</div>
-<div class="line"> } <span class="keywordflow">catch</span> (<span class="keyword">const</span> std::exception& e) {</div>
-<div class="line"> std::cerr << e.what() << std::endl;</div>
-<div class="line"> }</div>
-<div class="line"></div>
-<div class="line"> <span class="keywordflow">return</span> 1;</div>
-<div class="line">}</div>
-</div><!-- fragment --> </p>
+<p><div class="fragment"></div><!-- fragment --></p>
+<p>Our <code>main</code> function only differs in that it creates and runs a <code>socket::engine</code> instead of a <code>container</code>.</p>
+<p><div class="fragment"></div><!-- fragment --> </p>
</div></div><!-- contents -->
</div><!-- doc-content -->
<!-- start footer part -->
Added: qpid/site/docs/releases/qpid-proton-master/proton/cpp/api/type__id_8hpp.html
URL: http://svn.apache.org/viewvc/qpid/site/docs/releases/qpid-proton-master/proton/cpp/api/type__id_8hpp.html?rev=1739159&view=auto
==============================================================================
--- qpid/site/docs/releases/qpid-proton-master/proton/cpp/api/type__id_8hpp.html (added)
+++ qpid/site/docs/releases/qpid-proton-master/proton/cpp/api/type__id_8hpp.html Thu Apr 14 18:29:35 2016
@@ -0,0 +1,214 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://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.8.10"/>
+<title>Qpid Proton C++ API: proton/type_id.hpp File 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="navtree.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="resize.js"></script>
+<script type="text/javascript" src="navtreedata.js"></script>
+<script type="text/javascript" src="navtree.js"></script>
+<script type="text/javascript">
+ $(document).ready(initResizable);
+ $(window).load(resizeHeight);
+</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>
+<script type="text/javascript">
+ $(document).ready(function() { init_search(); });
+</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">Qpid Proton C++ API
+  <span id="projectnumber">master</span>
+ </div>
+ </td>
+ <td> <div id="MSearchBox" class="MSearchBoxInactive">
+ <span class="left">
+ <img id="MSearchSelect" src="search/mag_sel.png"
+ onmouseover="return searchBox.OnSearchSelectShow()"
+ onmouseout="return searchBox.OnSearchSelectHide()"
+ alt=""/>
+ <input type="text" id="MSearchField" value="Search" accesskey="S"
+ onfocus="searchBox.OnSearchFieldFocus(true)"
+ onblur="searchBox.OnSearchFieldFocus(false)"
+ onkeyup="searchBox.OnSearchFieldChange(event)"/>
+ </span><span class="right">
+ <a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
+ </span>
+ </div>
+</td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.10 -->
+<script type="text/javascript">
+var searchBox = new SearchBox("searchBox", "search",false,'Search');
+</script>
+</div><!-- top -->
+<div id="side-nav" class="ui-resizable side-nav-resizable">
+ <div id="nav-tree">
+ <div id="nav-tree-contents">
+ <div id="nav-sync" class="sync"></div>
+ </div>
+ </div>
+ <div id="splitbar" style="-moz-user-select:none;"
+ class="ui-resizable-handle">
+ </div>
+</div>
+<script type="text/javascript">
+$(document).ready(function(){initNavTree('type__id_8hpp.html','');});
+</script>
+<div id="doc-content">
+<!-- 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 class="header">
+ <div class="summary">
+<a href="#namespaces">Namespaces</a> |
+<a href="#enum-members">Enumerations</a> |
+<a href="#func-members">Functions</a> </div>
+ <div class="headertitle">
+<div class="title">type_id.hpp File Reference</div> </div>
+</div><!--header-->
+<div class="contents">
+
+<p>Type-identifiers for AMQP types.
+<a href="#details">More...</a></p>
+<div class="textblock"><code>#include <proton/export.hpp></code><br />
+<code>#include <proton/codec.h></code><br />
+<code>#include <string></code><br />
+</div>
+<p><a href="type__id_8hpp_source.html">Go to the source code of this file.</a></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="namespaces"></a>
+Namespaces</h2></td></tr>
+<tr class="memitem:namespaceproton"><td class="memItemLeft" align="right" valign="top">  </td><td class="memItemRight" valign="bottom"><a class="el" href="namespaceproton.html">proton</a></td></tr>
+<tr class="memdesc:namespaceproton"><td class="mdescLeft"> </td><td class="mdescRight">The proton namespace. <br /></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2"> </td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="enum-members"></a>
+Enumerations</h2></td></tr>
+<tr class="memitem:a83c2656d467d69eb49725c18f5aa13a9"><td class="memItemLeft" align="right" valign="top">enum  </td><td class="memItemRight" valign="bottom"><a class="el" href="namespaceproton.html#a83c2656d467d69eb49725c18f5aa13a9">type_id</a> { <br />
+  <a class="el" href="namespaceproton.html#a83c2656d467d69eb49725c18f5aa13a9a74cf8825b522b9721ea02973803d76b4">NULL_TYPE</a>,
+<a class="el" href="namespaceproton.html#a83c2656d467d69eb49725c18f5aa13a9a8a583f16e8d237a423c8c1d9087a4c72">BOOLEAN</a>,
+<a class="el" href="namespaceproton.html#a83c2656d467d69eb49725c18f5aa13a9a29dfb12306aac24cadeaa1f6bac455be">UBYTE</a>,
+<a class="el" href="namespaceproton.html#a83c2656d467d69eb49725c18f5aa13a9aa7f492d725033c06576ac4ba21007297">BYTE</a>,
+<br />
+  <a class="el" href="namespaceproton.html#a83c2656d467d69eb49725c18f5aa13a9a9ae509995ac75484348487a7477900ca">USHORT</a>,
+<a class="el" href="namespaceproton.html#a83c2656d467d69eb49725c18f5aa13a9a7a1fe3ba88f0c16cb494922948a9597d">SHORT</a>,
+<a class="el" href="namespaceproton.html#a83c2656d467d69eb49725c18f5aa13a9a4756f5bbd9f28d6b8905f32024b57398">UINT</a>,
+<a class="el" href="namespaceproton.html#a83c2656d467d69eb49725c18f5aa13a9afd5a5f51ce25953f3db2c7e93eb7864a">INT</a>,
+<br />
+  <a class="el" href="namespaceproton.html#a83c2656d467d69eb49725c18f5aa13a9a4618cf21306b3c647741afa7ebefcab8">CHAR</a>,
+<a class="el" href="namespaceproton.html#a83c2656d467d69eb49725c18f5aa13a9a574bf5ec73e28138b997d24464adb70c">ULONG</a>,
+<a class="el" href="namespaceproton.html#a83c2656d467d69eb49725c18f5aa13a9aaee055c4a5aba7d55774e4f1c01dacea">LONG</a>,
+<a class="el" href="namespaceproton.html#a83c2656d467d69eb49725c18f5aa13a9a3f2dbbd8fe9ad35caa594416336ceeda">TIMESTAMP</a>,
+<br />
+  <a class="el" href="namespaceproton.html#a83c2656d467d69eb49725c18f5aa13a9a9cf4a0866224b0bb4a7a895da27c9c4c">FLOAT</a>,
+<a class="el" href="namespaceproton.html#a83c2656d467d69eb49725c18f5aa13a9a33465d1d419b1074fb259ef444609e92">DOUBLE</a>,
+<a class="el" href="namespaceproton.html#a83c2656d467d69eb49725c18f5aa13a9a8df764f32f4aeba9ac8c7baccfd73388">DECIMAL32</a>,
+<a class="el" href="namespaceproton.html#a83c2656d467d69eb49725c18f5aa13a9a9a82428c8d08720e3134f1243496f7d6">DECIMAL64</a>,
+<br />
+  <a class="el" href="namespaceproton.html#a83c2656d467d69eb49725c18f5aa13a9ac68fb86fda41e4314b0ee0d00e3d5170">DECIMAL128</a>,
+<a class="el" href="namespaceproton.html#a83c2656d467d69eb49725c18f5aa13a9aaf1ea4a849fa4bcb9d351a6bde6d7600">UUID</a>,
+<a class="el" href="namespaceproton.html#a83c2656d467d69eb49725c18f5aa13a9aecafbc1299672a8c1521cc0d5f1ae986">BINARY</a>,
+<a class="el" href="namespaceproton.html#a83c2656d467d69eb49725c18f5aa13a9aee847e634a4297b274316de8a8ca9921">STRING</a>,
+<br />
+  <a class="el" href="namespaceproton.html#a83c2656d467d69eb49725c18f5aa13a9ae3d30ffaffa3c06ed917e565dda1fbc5">SYMBOL</a>,
+<a class="el" href="namespaceproton.html#a83c2656d467d69eb49725c18f5aa13a9a69c9d854e6a5430635ad44693470612d">DESCRIBED</a>,
+<a class="el" href="namespaceproton.html#a83c2656d467d69eb49725c18f5aa13a9a1e029fbf0c881b85d80fc8e89b753688">ARRAY</a>,
+<a class="el" href="namespaceproton.html#a83c2656d467d69eb49725c18f5aa13a9a25688e799536738ea469158ef15fd1c0">LIST</a>,
+<br />
+  <a class="el" href="namespaceproton.html#a83c2656d467d69eb49725c18f5aa13a9a4cafa5feda04184537b4d7d346e1e89b">MAP</a>
+<br />
+ }<tr class="memdesc:a83c2656d467d69eb49725c18f5aa13a9"><td class="mdescLeft"> </td><td class="mdescRight">An identifier for AMQP types. <a href="namespaceproton.html#a83c2656d467d69eb49725c18f5aa13a9">More...</a><br /></td></tr>
+<tr class="separator:a83c2656d467d69eb49725c18f5aa13a9"><td class="memSeparator" colspan="2"> </td></tr>
+</td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="func-members"></a>
+Functions</h2></td></tr>
+<tr class="memitem:a777b2887e8ee3a66e56ca9468007b586"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a777b2887e8ee3a66e56ca9468007b586"></a>
+std::string </td><td class="memItemRight" valign="bottom"><a class="el" href="namespaceproton.html#a777b2887e8ee3a66e56ca9468007b586">type_name</a> (type_id)</td></tr>
+<tr class="memdesc:a777b2887e8ee3a66e56ca9468007b586"><td class="mdescLeft"> </td><td class="mdescRight">Get the name of the AMQP type. <br /></td></tr>
+<tr class="separator:a777b2887e8ee3a66e56ca9468007b586"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:ada44820890dab1d51fb1efd5d5d5bc95"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ada44820890dab1d51fb1efd5d5d5bc95"></a>
+std::ostream & </td><td class="memItemRight" valign="bottom"><a class="el" href="namespaceproton.html#ada44820890dab1d51fb1efd5d5d5bc95">operator<<</a> (std::ostream &, type_id)</td></tr>
+<tr class="memdesc:ada44820890dab1d51fb1efd5d5d5bc95"><td class="mdescLeft"> </td><td class="mdescRight">Print the type name. <br /></td></tr>
+<tr class="separator:ada44820890dab1d51fb1efd5d5d5bc95"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aa77887032372174b09ee779f5df12056"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="aa77887032372174b09ee779f5df12056"></a>
+void </td><td class="memItemRight" valign="bottom"><a class="el" href="namespaceproton.html#aa77887032372174b09ee779f5df12056">assert_type_equal</a> (type_id want, type_id got)</td></tr>
+<tr class="memdesc:aa77887032372174b09ee779f5df12056"><td class="mdescLeft"> </td><td class="mdescRight">Throw a <a class="el" href="structproton_1_1conversion__error.html" title="Raised if there is an error converting between AMQP and C++ data. ">conversion_error</a> if want != got with a message including the names of the types. <br /></td></tr>
+<tr class="separator:aa77887032372174b09ee779f5df12056"><td class="memSeparator" colspan="2"> </td></tr>
+<tr><td colspan="2"><div class="groupHeader">Test propreties of a type_id.</div></td></tr>
+<tr class="memitem:aa41d60af81c2ea764268965cc7b126fa"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="aa41d60af81c2ea764268965cc7b126fa"></a>
+bool </td><td class="memItemRight" valign="bottom"><b>type_id_is_signed_int</b> (type_id t)</td></tr>
+<tr class="separator:aa41d60af81c2ea764268965cc7b126fa"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a1aa7e03ffe4296ae2308ceea397e6fb6"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a1aa7e03ffe4296ae2308ceea397e6fb6"></a>
+bool </td><td class="memItemRight" valign="bottom"><b>type_id_is_unsigned_int</b> (type_id t)</td></tr>
+<tr class="separator:a1aa7e03ffe4296ae2308ceea397e6fb6"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:af97c80a0a1b477e0b5128dc7d8ed6c00"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="af97c80a0a1b477e0b5128dc7d8ed6c00"></a>
+bool </td><td class="memItemRight" valign="bottom"><b>type_id_is_integral</b> (type_id t)</td></tr>
+<tr class="separator:af97c80a0a1b477e0b5128dc7d8ed6c00"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a87afe800bd34d635628b34cce437d0aa"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a87afe800bd34d635628b34cce437d0aa"></a>
+bool </td><td class="memItemRight" valign="bottom"><b>type_id_is_floating_point</b> (type_id t)</td></tr>
+<tr class="separator:a87afe800bd34d635628b34cce437d0aa"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a68019584ba84acd90424a306dac56184"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a68019584ba84acd90424a306dac56184"></a>
+bool </td><td class="memItemRight" valign="bottom"><b>type_id_is_decimal</b> (type_id t)</td></tr>
+<tr class="separator:a68019584ba84acd90424a306dac56184"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a97cb3b1f640cf8d0036998ecb61dbb3a"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a97cb3b1f640cf8d0036998ecb61dbb3a"></a>
+bool </td><td class="memItemRight" valign="bottom"><b>type_id_is_signed</b> (type_id t)</td></tr>
+<tr class="separator:a97cb3b1f640cf8d0036998ecb61dbb3a"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a8a83051cc916ba5b67144b2e4d78ecb1"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a8a83051cc916ba5b67144b2e4d78ecb1"></a>
+bool </td><td class="memItemRight" valign="bottom"><b>type_id_is_string_like</b> (type_id t)</td></tr>
+<tr class="separator:a8a83051cc916ba5b67144b2e4d78ecb1"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:aef7d66407548e1722486a5acd94cf01c"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="aef7d66407548e1722486a5acd94cf01c"></a>
+bool </td><td class="memItemRight" valign="bottom"><b>type_id_is_container</b> (type_id t)</td></tr>
+<tr class="separator:aef7d66407548e1722486a5acd94cf01c"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a4fa5da15b5f9ede62f8167c50c7dc656"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a4fa5da15b5f9ede62f8167c50c7dc656"></a>
+bool </td><td class="memItemRight" valign="bottom"><b>type_id_is_scalar</b> (type_id t)</td></tr>
+<tr class="separator:a4fa5da15b5f9ede62f8167c50c7dc656"><td class="memSeparator" colspan="2"> </td></tr>
+<tr class="memitem:a7c5a62fde33feb4887fea1935be0a518"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a7c5a62fde33feb4887fea1935be0a518"></a>
+bool </td><td class="memItemRight" valign="bottom"><b>type_id_is_null</b> (type_id t)</td></tr>
+<tr class="separator:a7c5a62fde33feb4887fea1935be0a518"><td class="memSeparator" colspan="2"> </td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><p>Type-identifiers for AMQP types. </p>
+</div></div><!-- contents -->
+</div><!-- doc-content -->
+<!-- start footer part -->
+<div id="nav-path" class="navpath"><!-- id is needed for treeview function! -->
+ <ul>
+ <li class="navelem"><a class="el" href="dir_25143d27009f52d175c1d192441a738a.html">proton</a></li><li class="navelem"><a class="el" href="type__id_8hpp.html">type_id.hpp</a></li>
+ <li class="footer">Generated by
+ <a href="http://www.doxygen.org/index.html">
+ <img class="footer" src="doxygen.png" alt="doxygen"/></a> 1.8.10 </li>
+ </ul>
+</div>
+</body>
+</html>
Propchange: qpid/site/docs/releases/qpid-proton-master/proton/cpp/api/type__id_8hpp.html
------------------------------------------------------------------------------
svn:executable = *
Added: qpid/site/docs/releases/qpid-proton-master/proton/cpp/api/type__id_8hpp.js
URL: http://svn.apache.org/viewvc/qpid/site/docs/releases/qpid-proton-master/proton/cpp/api/type__id_8hpp.js?rev=1739159&view=auto
==============================================================================
--- qpid/site/docs/releases/qpid-proton-master/proton/cpp/api/type__id_8hpp.js (added)
+++ qpid/site/docs/releases/qpid-proton-master/proton/cpp/api/type__id_8hpp.js Thu Apr 14 18:29:35 2016
@@ -0,0 +1,43 @@
+var type__id_8hpp =
+[
+ [ "type_id", "type__id_8hpp.html#a83c2656d467d69eb49725c18f5aa13a9", [
+ [ "NULL_TYPE", "type__id_8hpp.html#a83c2656d467d69eb49725c18f5aa13a9a74cf8825b522b9721ea02973803d76b4", null ],
+ [ "BOOLEAN", "type__id_8hpp.html#a83c2656d467d69eb49725c18f5aa13a9a8a583f16e8d237a423c8c1d9087a4c72", null ],
+ [ "UBYTE", "type__id_8hpp.html#a83c2656d467d69eb49725c18f5aa13a9a29dfb12306aac24cadeaa1f6bac455be", null ],
+ [ "BYTE", "type__id_8hpp.html#a83c2656d467d69eb49725c18f5aa13a9aa7f492d725033c06576ac4ba21007297", null ],
+ [ "USHORT", "type__id_8hpp.html#a83c2656d467d69eb49725c18f5aa13a9a9ae509995ac75484348487a7477900ca", null ],
+ [ "SHORT", "type__id_8hpp.html#a83c2656d467d69eb49725c18f5aa13a9a7a1fe3ba88f0c16cb494922948a9597d", null ],
+ [ "UINT", "type__id_8hpp.html#a83c2656d467d69eb49725c18f5aa13a9a4756f5bbd9f28d6b8905f32024b57398", null ],
+ [ "INT", "type__id_8hpp.html#a83c2656d467d69eb49725c18f5aa13a9afd5a5f51ce25953f3db2c7e93eb7864a", null ],
+ [ "CHAR", "type__id_8hpp.html#a83c2656d467d69eb49725c18f5aa13a9a4618cf21306b3c647741afa7ebefcab8", null ],
+ [ "ULONG", "type__id_8hpp.html#a83c2656d467d69eb49725c18f5aa13a9a574bf5ec73e28138b997d24464adb70c", null ],
+ [ "LONG", "type__id_8hpp.html#a83c2656d467d69eb49725c18f5aa13a9aaee055c4a5aba7d55774e4f1c01dacea", null ],
+ [ "TIMESTAMP", "type__id_8hpp.html#a83c2656d467d69eb49725c18f5aa13a9a3f2dbbd8fe9ad35caa594416336ceeda", null ],
+ [ "FLOAT", "type__id_8hpp.html#a83c2656d467d69eb49725c18f5aa13a9a9cf4a0866224b0bb4a7a895da27c9c4c", null ],
+ [ "DOUBLE", "type__id_8hpp.html#a83c2656d467d69eb49725c18f5aa13a9a33465d1d419b1074fb259ef444609e92", null ],
+ [ "DECIMAL32", "type__id_8hpp.html#a83c2656d467d69eb49725c18f5aa13a9a8df764f32f4aeba9ac8c7baccfd73388", null ],
+ [ "DECIMAL64", "type__id_8hpp.html#a83c2656d467d69eb49725c18f5aa13a9a9a82428c8d08720e3134f1243496f7d6", null ],
+ [ "DECIMAL128", "type__id_8hpp.html#a83c2656d467d69eb49725c18f5aa13a9ac68fb86fda41e4314b0ee0d00e3d5170", null ],
+ [ "UUID", "type__id_8hpp.html#a83c2656d467d69eb49725c18f5aa13a9aaf1ea4a849fa4bcb9d351a6bde6d7600", null ],
+ [ "BINARY", "type__id_8hpp.html#a83c2656d467d69eb49725c18f5aa13a9aecafbc1299672a8c1521cc0d5f1ae986", null ],
+ [ "STRING", "type__id_8hpp.html#a83c2656d467d69eb49725c18f5aa13a9aee847e634a4297b274316de8a8ca9921", null ],
+ [ "SYMBOL", "type__id_8hpp.html#a83c2656d467d69eb49725c18f5aa13a9ae3d30ffaffa3c06ed917e565dda1fbc5", null ],
+ [ "DESCRIBED", "type__id_8hpp.html#a83c2656d467d69eb49725c18f5aa13a9a69c9d854e6a5430635ad44693470612d", null ],
+ [ "ARRAY", "type__id_8hpp.html#a83c2656d467d69eb49725c18f5aa13a9a1e029fbf0c881b85d80fc8e89b753688", null ],
+ [ "LIST", "type__id_8hpp.html#a83c2656d467d69eb49725c18f5aa13a9a25688e799536738ea469158ef15fd1c0", null ],
+ [ "MAP", "type__id_8hpp.html#a83c2656d467d69eb49725c18f5aa13a9a4cafa5feda04184537b4d7d346e1e89b", null ]
+ ] ],
+ [ "assert_type_equal", "type__id_8hpp.html#aa77887032372174b09ee779f5df12056", null ],
+ [ "operator<<", "type__id_8hpp.html#ada44820890dab1d51fb1efd5d5d5bc95", null ],
+ [ "type_id_is_container", "type__id_8hpp.html#aef7d66407548e1722486a5acd94cf01c", null ],
+ [ "type_id_is_decimal", "type__id_8hpp.html#a68019584ba84acd90424a306dac56184", null ],
+ [ "type_id_is_floating_point", "type__id_8hpp.html#a87afe800bd34d635628b34cce437d0aa", null ],
+ [ "type_id_is_integral", "type__id_8hpp.html#af97c80a0a1b477e0b5128dc7d8ed6c00", null ],
+ [ "type_id_is_null", "type__id_8hpp.html#a7c5a62fde33feb4887fea1935be0a518", null ],
+ [ "type_id_is_scalar", "type__id_8hpp.html#a4fa5da15b5f9ede62f8167c50c7dc656", null ],
+ [ "type_id_is_signed", "type__id_8hpp.html#a97cb3b1f640cf8d0036998ecb61dbb3a", null ],
+ [ "type_id_is_signed_int", "type__id_8hpp.html#aa41d60af81c2ea764268965cc7b126fa", null ],
+ [ "type_id_is_string_like", "type__id_8hpp.html#a8a83051cc916ba5b67144b2e4d78ecb1", null ],
+ [ "type_id_is_unsigned_int", "type__id_8hpp.html#a1aa7e03ffe4296ae2308ceea397e6fb6", null ],
+ [ "type_name", "type__id_8hpp.html#a777b2887e8ee3a66e56ca9468007b586", null ]
+];
\ No newline at end of file
Propchange: qpid/site/docs/releases/qpid-proton-master/proton/cpp/api/type__id_8hpp.js
------------------------------------------------------------------------------
svn:executable = *
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@qpid.apache.org
For additional commands, e-mail: commits-help@qpid.apache.org