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/07/13 09:54:54 UTC
[09/26] qpid-site git commit: QPID-7350: Examples that should have
gone with the previous commit
http://git-wip-us.apache.org/repos/asf/qpid-site/blob/75ca8b14/input/releases/qpid-proton-0.13.0/proton/cpp/examples/direct_send.cpp.html.in
----------------------------------------------------------------------
diff --git a/input/releases/qpid-proton-0.13.0/proton/cpp/examples/direct_send.cpp.html.in b/input/releases/qpid-proton-0.13.0/proton/cpp/examples/direct_send.cpp.html.in
new file mode 100644
index 0000000..5b29bba
--- /dev/null
+++ b/input/releases/qpid-proton-0.13.0/proton/cpp/examples/direct_send.cpp.html.in
@@ -0,0 +1,85 @@
+
+<h1>direct_send.cpp</h1>
+<div class="highlight"><pre><span></span><span class="cp">#include</span> <span class="cpf">"options.hpp"</span><span class="cp"></span>
+
+<span class="cp">#include</span> <span class="cpf"><proton/connection.hpp></span><span class="cp"></span>
+<span class="cp">#include</span> <span class="cpf"><proton/default_container.hpp></span><span class="cp"></span>
+<span class="cp">#include</span> <span class="cpf"><proton/messaging_handler.hpp></span><span class="cp"></span>
+<span class="cp">#include</span> <span class="cpf"><proton/value.hpp></span><span class="cp"></span>
+<span class="cp">#include</span> <span class="cpf"><proton/tracker.hpp></span><span class="cp"></span>
+
+<span class="cp">#include</span> <span class="cpf"><iostream></span><span class="cp"></span>
+<span class="cp">#include</span> <span class="cpf"><map></span><span class="cp"></span>
+
+<span class="cp">#include</span> <span class="cpf">"fake_cpp11.hpp"</span><span class="cp"></span>
+
+<span class="k">class</span> <span class="nc">simple_send</span> <span class="o">:</span> <span class="k">public</span> <span class="n">proton</span><span class="o">::</span><span class="n">messaging_handler</span> <span class="p">{</span>
+ <span class="k">private</span><span class="o">:</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">url</span><span class="p">;</span>
+ <span class="n">proton</span><span class="o">::</span><span class="n">listener</span> <span class="n">listener</span><span class="p">;</span>
+ <span class="kt">int</span> <span class="n">sent</span><span class="p">;</span>
+ <span class="kt">int</span> <span class="n">confirmed</span><span class="p">;</span>
+ <span class="kt">int</span> <span class="n">total</span><span class="p">;</span>
+
+ <span class="k">public</span><span class="o">:</span>
+ <span class="n">simple_send</span><span class="p">(</span><span class="k">const</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="o">&</span><span class="n">s</span><span class="p">,</span> <span class="kt">int</span> <span class="n">c</span><span class="p">)</span> <span class="o">:</span> <span class="n">url</span><span class="p">(</span><span class="n">s</span><span class="p">),</span> <span class="n">sent</span><span class="p">(</span><span class="mi">0</span><span class="p">),</span> <span class="n">confirmed</span><span class="p">(</span><span class="mi">0</span><span class="p">),</span> <span class="n">total</span><span class="p">(</span><span class="n">c</span><span class="p">)</span> <span class="p">{}</span>
+
+ <span class="kt">void</span> <span class="n">on_container_start</span><span class="p">(</span><span class="n">proton</span><span class="o">::</span><span class="n">container</span> <span class="o">&</span><span class="n">c</span><span class="p">)</span> <span class="n">OVERRIDE</span> <span class="p">{</span>
+ <span class="n">listener</span> <span class="o">=</span> <span class="n">c</span><span class="p">.</span><span class="n">listen</span><span class="p">(</span><span class="n">url</span><span class="p">);</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"direct_send listening on "</span> <span class="o"><<</span> <span class="n">url</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
+ <span class="p">}</span>
+
+ <span class="kt">void</span> <span class="n">on_sendable</span><span class="p">(</span><span class="n">proton</span><span class="o">::</span><span class="n">sender</span> <span class="o">&</span><span class="n">sender</span><span class="p">)</span> <span class="n">OVERRIDE</span> <span class="p">{</span>
+ <span class="k">while</span> <span class="p">(</span><span class="n">sender</span><span class="p">.</span><span class="n">credit</span><span class="p">()</span> <span class="o">&&</span> <span class="n">sent</span> <span class="o"><</span> <span class="n">total</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">proton</span><span class="o">::</span><span class="n">message</span> <span class="n">msg</span><span class="p">;</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">map</span><span class="o"><</span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="p">,</span> <span class="kt">int</span><span class="o">></span> <span class="n">m</span><span class="p">;</span>
+ <span class="n">m</span><span class="p">[</span><span class="s">"sequence"</span><span class="p">]</span> <span class="o">=</span> <span class="n">sent</span> <span class="o">+</span> <span class="mi">1</span><span class="p">;</span>
+
+ <span class="n">msg</span><span class="p">.</span><span class="n">id</span><span class="p">(</span><span class="n">sent</span> <span class="o">+</span> <span class="mi">1</span><span class="p">);</span>
+ <span class="n">msg</span><span class="p">.</span><span class="n">body</span><span class="p">(</span><span class="n">m</span><span class="p">);</span>
+
+ <span class="n">sender</span><span class="p">.</span><span class="n">send</span><span class="p">(</span><span class="n">msg</span><span class="p">);</span>
+ <span class="n">sent</span><span class="o">++</span><span class="p">;</span>
+ <span class="p">}</span>
+ <span class="p">}</span>
+
+ <span class="kt">void</span> <span class="n">on_tracker_accept</span><span class="p">(</span><span class="n">proton</span><span class="o">::</span><span class="n">tracker</span> <span class="o">&</span><span class="n">t</span><span class="p">)</span> <span class="n">OVERRIDE</span> <span class="p">{</span>
+ <span class="n">confirmed</span><span class="o">++</span><span class="p">;</span>
+
+ <span class="k">if</span> <span class="p">(</span><span class="n">confirmed</span> <span class="o">==</span> <span class="n">total</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"all messages confirmed"</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
+ <span class="n">t</span><span class="p">.</span><span class="n">connection</span><span class="p">().</span><span class="n">close</span><span class="p">();</span>
+ <span class="n">listener</span><span class="p">.</span><span class="n">stop</span><span class="p">();</span>
+ <span class="p">}</span>
+ <span class="p">}</span>
+
+ <span class="kt">void</span> <span class="n">on_transport_close</span><span class="p">(</span><span class="n">proton</span><span class="o">::</span><span class="n">transport</span> <span class="o">&</span><span class="p">)</span> <span class="n">OVERRIDE</span> <span class="p">{</span>
+ <span class="n">sent</span> <span class="o">=</span> <span class="n">confirmed</span><span class="p">;</span>
+ <span class="p">}</span>
+<span class="p">};</span>
+
+<span class="kt">int</span> <span class="nf">main</span><span class="p">(</span><span class="kt">int</span> <span class="n">argc</span><span class="p">,</span> <span class="kt">char</span> <span class="o">**</span><span class="n">argv</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">address</span><span class="p">(</span><span class="s">"127.0.0.1:5672/examples"</span><span class="p">);</span>
+ <span class="kt">int</span> <span class="n">message_count</span> <span class="o">=</span> <span class="mi">100</span><span class="p">;</span>
+ <span class="n">example</span><span class="o">::</span><span class="n">options</span> <span class="n">opts</span><span class="p">(</span><span class="n">argc</span><span class="p">,</span> <span class="n">argv</span><span class="p">);</span>
+
+ <span class="n">opts</span><span class="p">.</span><span class="n">add_value</span><span class="p">(</span><span class="n">address</span><span class="p">,</span> <span class="sc">'a'</span><span class="p">,</span> <span class="s">"address"</span><span class="p">,</span> <span class="s">"listen and send on URL"</span><span class="p">,</span> <span class="s">"URL"</span><span class="p">);</span>
+ <span class="n">opts</span><span class="p">.</span><span class="n">add_value</span><span class="p">(</span><span class="n">message_count</span><span class="p">,</span> <span class="sc">'m'</span><span class="p">,</span> <span class="s">"messages"</span><span class="p">,</span> <span class="s">"send COUNT messages"</span><span class="p">,</span> <span class="s">"COUNT"</span><span class="p">);</span>
+
+ <span class="k">try</span> <span class="p">{</span>
+ <span class="n">opts</span><span class="p">.</span><span class="n">parse</span><span class="p">();</span>
+
+ <span class="n">simple_send</span> <span class="n">send</span><span class="p">(</span><span class="n">address</span><span class="p">,</span> <span class="n">message_count</span><span class="p">);</span>
+ <span class="n">proton</span><span class="o">::</span><span class="n">default_container</span><span class="p">(</span><span class="n">send</span><span class="p">).</span><span class="n">run</span><span class="p">();</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+ <span class="p">}</span> <span class="k">catch</span> <span class="p">(</span><span class="k">const</span> <span class="n">example</span><span class="o">::</span><span class="n">bad_option</span><span class="o">&</span> <span class="n">e</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="n">opts</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span> <span class="o"><<</span> <span class="n">e</span><span class="p">.</span><span class="n">what</span><span class="p">()</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
+ <span class="p">}</span> <span class="k">catch</span> <span class="p">(</span><span class="k">const</span> <span class="n">std</span><span class="o">::</span><span class="n">exception</span><span class="o">&</span> <span class="n">e</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">cerr</span> <span class="o"><<</span> <span class="n">e</span><span class="p">.</span><span class="n">what</span><span class="p">()</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
+ <span class="p">}</span>
+
+ <span class="k">return</span> <span class="mi">1</span><span class="p">;</span>
+<span class="p">}</span>
+</pre></div>
+
+<p><a href="direct_send.cpp">Download this file</a></p>
http://git-wip-us.apache.org/repos/asf/qpid-site/blob/75ca8b14/input/releases/qpid-proton-0.13.0/proton/cpp/examples/encode_decode.cpp
----------------------------------------------------------------------
diff --git a/input/releases/qpid-proton-0.13.0/proton/cpp/examples/encode_decode.cpp b/input/releases/qpid-proton-0.13.0/proton/cpp/examples/encode_decode.cpp
new file mode 100644
index 0000000..17971d9
--- /dev/null
+++ b/input/releases/qpid-proton-0.13.0/proton/cpp/examples/encode_decode.cpp
@@ -0,0 +1,252 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include <proton/types.hpp>
+#include <proton/codec/encoder.hpp>
+#include <proton/codec/decoder.hpp>
+
+#include <algorithm>
+#include <iostream>
+#include <iterator>
+#include <sstream>
+
+// Examples of how to use the encoder and decoder to create and examine AMQP values.
+//
+
+// Print is defined at the end as an example of how to query and extract complex
+// values from a decoder in terms of their simple components.
+void print(proton::value&);
+
+// Some helper templates to print map and std::vector results.
+namespace std {
+template<class T, class U> ostream& operator<<(ostream& o, const std::pair<T,U>& p) {
+ return o << p.first << ":" << p.second;
+}
+template<class T> ostream& operator<<(ostream& o, const std::vector<T>& v) {
+ o << "[ ";
+ ostream_iterator<T> oi(o, " ");
+ copy(v.begin(), v.end(), oi);
+ return o << "]";
+}
+template<class T> ostream& operator<<(ostream& o, const std::list<T>& v) {
+ o << "[ ";
+ ostream_iterator<T> oi(o, " ");
+ copy(v.begin(), v.end(), oi);
+ return o << "]";
+}
+template<class K, class T> ostream& operator<<(ostream& o, const map<K, T>& m) {
+ o << "{ ";
+ ostream_iterator<std::pair<K,T> > oi(o, " ");
+ copy(m.begin(), m.end(), oi);
+ return o << "}";
+}
+}
+
+// Insert/extract native C++ containers with uniform type values.
+static void uniform_containers() {
+ std::cout << std::endl << "== Array, list and map of uniform type." << std::endl;
+ proton::value v;
+
+ std::vector<int> a;
+ a.push_back(1);
+ a.push_back(2);
+ a.push_back(3);
+ // By default a C++ container is encoded as an AMQP array.
+ v = a;
+ print(v);
+ std::list<int> a1;
+ proton::get(v, a1);
+ std::cout << a1 << std::endl;
+
+ // You can specify that a container should be encoded as an AMQP list instead.
+ v = proton::codec::encoder::list(a1);
+ print(v);
+ std::cout << proton::get<std::vector<int> >(v) << std::endl;
+
+ // C++ map types (types with key_type, mapped_type) convert to an AMQP map by default.
+ std::map<std::string, int> m;
+ m["one"] = 1;
+ m["two"] = 2;
+ v = m;
+ print(v);
+ std::cout << proton::get<std::map<std::string, int> >(v) << std::endl;
+
+ // A sequence of pairs encodes as an AMQP MAP, which lets you control the encoded order.
+ std::vector<std::pair<std::string, int> > pairs;
+ pairs.push_back(std::make_pair("z", 3));
+ pairs.push_back(std::make_pair("a", 4));
+ v = pairs;
+ print(v);
+
+ // You can also decode an AMQP map as a sequence of pairs to preserve encode order.
+ std::vector<std::pair<std::string, int> > pairs2;
+ proton::codec::decoder d(v);
+ d >> pairs2;
+ std::cout << pairs2 << std::endl;
+
+ // A vector of proton::value is normally encoded as a mixed-type AMQP LIST,
+ // but you can encoded it as an array provided all the values match the array type.
+ std::vector<proton::value> vv;
+ vv.push_back(proton::value("a"));
+ vv.push_back(proton::value("b"));
+ vv.push_back(proton::value("c"));
+ v = vv;
+ print(v);
+}
+
+// Containers with mixed types use value to represent arbitrary AMQP types.
+static void mixed_containers() {
+ std::cout << std::endl << "== List and map of mixed type values." << std::endl;
+ proton::value v;
+
+ std::vector<proton::value> l;
+ l.push_back(proton::value(42));
+ l.push_back(proton::value(std::string("foo")));
+ // By default, a sequence of proton::value is treated as an AMQP list.
+ v = l;
+ print(v);
+ std::vector<proton::value> l2 = proton::get<std::vector<proton::value> >(v);
+ std::cout << l2 << std::endl;
+
+ std::map<proton::value, proton::value> m;
+ m[proton::value("five")] = proton::value(5);
+ m[proton::value(4)] = proton::value("four"); v = m;
+ print(v);
+ typedef std::map<proton::value, proton::value> value_map;
+ value_map m2(proton::get<value_map>(v));
+ std::cout << m2 << std::endl;
+}
+
+// Insert using stream operators (see print_next for example of extracting with stream ops.)
+static void insert_stream_operators() {
+ std::cout << std::endl << "== Insert with stream operators." << std::endl;
+ proton::value v;
+
+ // Create an array of INT with values [1, 2, 3]
+ proton::codec::encoder e(v);
+ e << proton::codec::start::array(proton::INT)
+ << int32_t(1) << int32_t(2) << int32_t(3)
+ << proton::codec::finish();
+ print(v);
+
+ // Create a mixed-type list of the values [42, false, "x"].
+ proton::codec::encoder e2(v);
+ e2 << proton::codec::start::list()
+ << int32_t(42) << false << proton::symbol("x")
+ << proton::codec::finish();
+ print(v);
+
+ // Create a map { "k1":42, "k2": false }
+ proton::codec::encoder e3(v);
+ e3 << proton::codec::start::map()
+ << "k1" << int32_t(42)
+ << proton::symbol("k2") << false
+ << proton::codec::finish();
+ print(v);
+}
+
+int main(int, char**) {
+ try {
+ uniform_containers();
+ mixed_containers();
+ insert_stream_operators();
+ return 0;
+ } catch (const std::exception& e) {
+ std::cerr << std::endl << "error: " << e.what() << std::endl;
+ }
+ return 1;
+}
+
+// print_next prints the next value from values by recursively descending into complex values.
+//
+// NOTE this is for example puroses only: There is a built in ostream operator<< for values.
+//
+//
+static void print_next(proton::codec::decoder& d) {
+ proton::type_id type = d.next_type();
+ proton::codec::start s;
+ switch (type) {
+ case proton::ARRAY: {
+ d >> s;
+ std::cout << "array<" << s.element;
+ if (s.is_described) {
+ std::cout << ", descriptor=";
+ print_next(d);
+ }
+ std::cout << ">[";
+ for (size_t i = 0; i < s.size; ++i) {
+ if (i) std::cout << ", ";
+ print_next(d);
+ }
+ std::cout << "]";
+ d >> proton::codec::finish();
+ break;
+ }
+ case proton::LIST: {
+ d >> s;
+ std::cout << "list[";
+ for (size_t i = 0; i < s.size; ++i) {
+ if (i) std::cout << ", ";
+ print_next(d);
+ }
+ std::cout << "]";
+ d >> proton::codec::finish();
+ break;
+ }
+ case proton::MAP: {
+ d >> s;
+ std::cout << "map{";
+ for (size_t i = 0; i < s.size/2; ++i) {
+ if (i) std::cout << ", ";
+ print_next(d);
+ std::cout << ":"; // key:value
+ print_next(d);
+ }
+ std::cout << "}";
+ d >> proton::codec::finish();
+ break;
+ }
+ case proton::DESCRIBED: {
+ d >> s;
+ std::cout << "described(";
+ print_next(d); // Descriptor
+ print_next(d); // value
+ d >> proton::codec::finish();
+ break;
+ }
+ default:
+ // A simple type. We could continue the switch for all AMQP types but
+ // we will take a short cut and extract to another value and print that.
+ proton::value v2;
+ d >> v2;
+ std::cout << type << "(" << v2 << ")";
+ }
+}
+
+// Print a value, for example purposes. Normal code can use operator<<
+void print(proton::value& v) {
+ proton::codec::decoder d(v);
+ d.rewind();
+ std::cout << std::boolalpha; // Print boolean as true/false.
+ while (d.more()) {
+ print_next(d);
+ if (d.more()) std::cout << ", ";
+ }
+ std::cout << std::endl;
+}
http://git-wip-us.apache.org/repos/asf/qpid-site/blob/75ca8b14/input/releases/qpid-proton-0.13.0/proton/cpp/examples/encode_decode.cpp.html.in
----------------------------------------------------------------------
diff --git a/input/releases/qpid-proton-0.13.0/proton/cpp/examples/encode_decode.cpp.html.in b/input/releases/qpid-proton-0.13.0/proton/cpp/examples/encode_decode.cpp.html.in
new file mode 100644
index 0000000..6ec6c85
--- /dev/null
+++ b/input/releases/qpid-proton-0.13.0/proton/cpp/examples/encode_decode.cpp.html.in
@@ -0,0 +1,238 @@
+
+<h1>encode_decode.cpp</h1>
+<div class="highlight"><pre><span></span><span class="cp">#include</span> <span class="cpf"><proton/types.hpp></span><span class="cp"></span>
+<span class="cp">#include</span> <span class="cpf"><proton/codec/encoder.hpp></span><span class="cp"></span>
+<span class="cp">#include</span> <span class="cpf"><proton/codec/decoder.hpp></span><span class="cp"></span>
+
+<span class="cp">#include</span> <span class="cpf"><algorithm></span><span class="cp"></span>
+<span class="cp">#include</span> <span class="cpf"><iostream></span><span class="cp"></span>
+<span class="cp">#include</span> <span class="cpf"><iterator></span><span class="cp"></span>
+<span class="cp">#include</span> <span class="cpf"><sstream></span><span class="cp"></span>
+
+<span class="c1">// Examples of how to use the encoder and decoder to create and examine AMQP values.</span>
+<span class="c1">//</span>
+
+<span class="c1">// Print is defined at the end as an example of how to query and extract complex</span>
+<span class="c1">// values from a decoder in terms of their simple components.</span>
+<span class="kt">void</span> <span class="nf">print</span><span class="p">(</span><span class="n">proton</span><span class="o">::</span><span class="n">value</span><span class="o">&</span><span class="p">);</span>
+
+<span class="c1">// Some helper templates to print map and std::vector results.</span>
+<span class="k">namespace</span> <span class="n">std</span> <span class="p">{</span>
+<span class="k">template</span><span class="o"><</span><span class="k">class</span> <span class="nc">T</span><span class="p">,</span> <span class="k">class</span> <span class="nc">U</span><span class="o">></span> <span class="n">ostream</span><span class="o">&</span> <span class="k">operator</span><span class="o"><<</span><span class="p">(</span><span class="n">ostream</span><span class="o">&</span> <span class="n">o</span><span class="p">,</span> <span class="k">const</span> <span class="n">std</span><span class="o">::</span><span class="n">pair</span><span class="o"><</span><span class="n">T</span><span class="p">,</span><span class="n">U</span><span class="o">>&</span> <span class="n">p</span><span class="p">)</span> <span class="p">{</span>
+ <span class="k">return</span> <span class="n">o</span> <span class="o"><<</span> <span class="n">p</span><span class="p">.</span><span class="n">first</span> <span class="o"><<</span> <span class="s">":"</span> <span class="o"><<</span> <span class="n">p</span><span class="p">.</span><span class="n">second</span><span class="p">;</span>
+<span class="p">}</span>
+<span class="k">template</span><span class="o"><</span><span class="k">class</span> <span class="nc">T</span><span class="o">></span> <span class="n">ostream</span><span class="o">&</span> <span class="k">operator</span><span class="o"><<</span><span class="p">(</span><span class="n">ostream</span><span class="o">&</span> <span class="n">o</span><span class="p">,</span> <span class="k">const</span> <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">T</span><span class="o">>&</span> <span class="n">v</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">o</span> <span class="o"><<</span> <span class="s">"[ "</span><span class="p">;</span>
+ <span class="n">ostream_iterator</span><span class="o"><</span><span class="n">T</span><span class="o">></span> <span class="n">oi</span><span class="p">(</span><span class="n">o</span><span class="p">,</span> <span class="s">" "</span><span class="p">);</span>
+ <span class="n">copy</span><span class="p">(</span><span class="n">v</span><span class="p">.</span><span class="n">begin</span><span class="p">(),</span> <span class="n">v</span><span class="p">.</span><span class="n">end</span><span class="p">(),</span> <span class="n">oi</span><span class="p">);</span>
+ <span class="k">return</span> <span class="n">o</span> <span class="o"><<</span> <span class="s">"]"</span><span class="p">;</span>
+<span class="p">}</span>
+<span class="k">template</span><span class="o"><</span><span class="k">class</span> <span class="nc">T</span><span class="o">></span> <span class="n">ostream</span><span class="o">&</span> <span class="k">operator</span><span class="o"><<</span><span class="p">(</span><span class="n">ostream</span><span class="o">&</span> <span class="n">o</span><span class="p">,</span> <span class="k">const</span> <span class="n">std</span><span class="o">::</span><span class="n">list</span><span class="o"><</span><span class="n">T</span><span class="o">>&</span> <span class="n">v</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">o</span> <span class="o"><<</span> <span class="s">"[ "</span><span class="p">;</span>
+ <span class="n">ostream_iterator</span><span class="o"><</span><span class="n">T</span><span class="o">></span> <span class="n">oi</span><span class="p">(</span><span class="n">o</span><span class="p">,</span> <span class="s">" "</span><span class="p">);</span>
+ <span class="n">copy</span><span class="p">(</span><span class="n">v</span><span class="p">.</span><span class="n">begin</span><span class="p">(),</span> <span class="n">v</span><span class="p">.</span><span class="n">end</span><span class="p">(),</span> <span class="n">oi</span><span class="p">);</span>
+ <span class="k">return</span> <span class="n">o</span> <span class="o"><<</span> <span class="s">"]"</span><span class="p">;</span>
+<span class="p">}</span>
+<span class="k">template</span><span class="o"><</span><span class="k">class</span> <span class="nc">K</span><span class="p">,</span> <span class="k">class</span> <span class="nc">T</span><span class="o">></span> <span class="n">ostream</span><span class="o">&</span> <span class="k">operator</span><span class="o"><<</span><span class="p">(</span><span class="n">ostream</span><span class="o">&</span> <span class="n">o</span><span class="p">,</span> <span class="k">const</span> <span class="n">map</span><span class="o"><</span><span class="n">K</span><span class="p">,</span> <span class="n">T</span><span class="o">>&</span> <span class="n">m</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">o</span> <span class="o"><<</span> <span class="s">"{ "</span><span class="p">;</span>
+ <span class="n">ostream_iterator</span><span class="o"><</span><span class="n">std</span><span class="o">::</span><span class="n">pair</span><span class="o"><</span><span class="n">K</span><span class="p">,</span><span class="n">T</span><span class="o">></span> <span class="o">></span> <span class="n">oi</span><span class="p">(</span><span class="n">o</span><span class="p">,</span> <span class="s">" "</span><span class="p">);</span>
+ <span class="n">copy</span><span class="p">(</span><span class="n">m</span><span class="p">.</span><span class="n">begin</span><span class="p">(),</span> <span class="n">m</span><span class="p">.</span><span class="n">end</span><span class="p">(),</span> <span class="n">oi</span><span class="p">);</span>
+ <span class="k">return</span> <span class="n">o</span> <span class="o"><<</span> <span class="s">"}"</span><span class="p">;</span>
+<span class="p">}</span>
+<span class="p">}</span>
+
+<span class="c1">// Insert/extract native C++ containers with uniform type values.</span>
+<span class="k">static</span> <span class="kt">void</span> <span class="n">uniform_containers</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span> <span class="o"><<</span> <span class="s">"== Array, list and map of uniform type."</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
+ <span class="n">proton</span><span class="o">::</span><span class="n">value</span> <span class="n">v</span><span class="p">;</span>
+
+ <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="kt">int</span><span class="o">></span> <span class="n">a</span><span class="p">;</span>
+ <span class="n">a</span><span class="p">.</span><span class="n">push_back</span><span class="p">(</span><span class="mi">1</span><span class="p">);</span>
+ <span class="n">a</span><span class="p">.</span><span class="n">push_back</span><span class="p">(</span><span class="mi">2</span><span class="p">);</span>
+ <span class="n">a</span><span class="p">.</span><span class="n">push_back</span><span class="p">(</span><span class="mi">3</span><span class="p">);</span>
+ <span class="c1">// By default a C++ container is encoded as an AMQP array.</span>
+ <span class="n">v</span> <span class="o">=</span> <span class="n">a</span><span class="p">;</span>
+ <span class="n">print</span><span class="p">(</span><span class="n">v</span><span class="p">);</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">list</span><span class="o"><</span><span class="kt">int</span><span class="o">></span> <span class="n">a1</span><span class="p">;</span>
+ <span class="n">proton</span><span class="o">::</span><span class="n">get</span><span class="p">(</span><span class="n">v</span><span class="p">,</span> <span class="n">a1</span><span class="p">);</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="n">a1</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
+
+ <span class="c1">// You can specify that a container should be encoded as an AMQP list instead.</span>
+ <span class="n">v</span> <span class="o">=</span> <span class="n">proton</span><span class="o">::</span><span class="n">codec</span><span class="o">::</span><span class="n">encoder</span><span class="o">::</span><span class="n">list</span><span class="p">(</span><span class="n">a1</span><span class="p">);</span>
+ <span class="n">print</span><span class="p">(</span><span class="n">v</span><span class="p">);</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="n">proton</span><span class="o">::</span><span class="n">get</span><span class="o"><</span><span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="kt">int</span><span class="o">></span> <span class="o">></span><span class="p">(</span><span class="n">v</span><span class="p">)</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
+
+ <span class="c1">// C++ map types (types with key_type, mapped_type) convert to an AMQP map by default.</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">map</span><span class="o"><</span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="p">,</span> <span class="kt">int</span><span class="o">></span> <span class="n">m</span><span class="p">;</span>
+ <span class="n">m</span><span class="p">[</span><span class="s">"one"</span><span class="p">]</span> <span class="o">=</span> <span class="mi">1</span><span class="p">;</span>
+ <span class="n">m</span><span class="p">[</span><span class="s">"two"</span><span class="p">]</span> <span class="o">=</span> <span class="mi">2</span><span class="p">;</span>
+ <span class="n">v</span> <span class="o">=</span> <span class="n">m</span><span class="p">;</span>
+ <span class="n">print</span><span class="p">(</span><span class="n">v</span><span class="p">);</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="n">proton</span><span class="o">::</span><span class="n">get</span><span class="o"><</span><span class="n">std</span><span class="o">::</span><span class="n">map</span><span class="o"><</span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="p">,</span> <span class="kt">int</span><span class="o">></span> <span class="o">></span><span class="p">(</span><span class="n">v</span><span class="p">)</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
+
+ <span class="c1">// A sequence of pairs encodes as an AMQP MAP, which lets you control the encoded order.</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">std</span><span class="o">::</span><span class="n">pair</span><span class="o"><</span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="p">,</span> <span class="kt">int</span><span class="o">></span> <span class="o">></span> <span class="n">pairs</span><span class="p">;</span>
+ <span class="n">pairs</span><span class="p">.</span><span class="n">push_back</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">make_pair</span><span class="p">(</span><span class="s">"z"</span><span class="p">,</span> <span class="mi">3</span><span class="p">));</span>
+ <span class="n">pairs</span><span class="p">.</span><span class="n">push_back</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">make_pair</span><span class="p">(</span><span class="s">"a"</span><span class="p">,</span> <span class="mi">4</span><span class="p">));</span>
+ <span class="n">v</span> <span class="o">=</span> <span class="n">pairs</span><span class="p">;</span>
+ <span class="n">print</span><span class="p">(</span><span class="n">v</span><span class="p">);</span>
+
+ <span class="c1">// You can also decode an AMQP map as a sequence of pairs to preserve encode order.</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">std</span><span class="o">::</span><span class="n">pair</span><span class="o"><</span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="p">,</span> <span class="kt">int</span><span class="o">></span> <span class="o">></span> <span class="n">pairs2</span><span class="p">;</span>
+ <span class="n">proton</span><span class="o">::</span><span class="n">codec</span><span class="o">::</span><span class="n">decoder</span> <span class="n">d</span><span class="p">(</span><span class="n">v</span><span class="p">);</span>
+ <span class="n">d</span> <span class="o">>></span> <span class="n">pairs2</span><span class="p">;</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="n">pairs2</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
+
+ <span class="c1">// A vector of proton::value is normally encoded as a mixed-type AMQP LIST,</span>
+ <span class="c1">// but you can encoded it as an array provided all the values match the array type.</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">proton</span><span class="o">::</span><span class="n">value</span><span class="o">></span> <span class="n">vv</span><span class="p">;</span>
+ <span class="n">vv</span><span class="p">.</span><span class="n">push_back</span><span class="p">(</span><span class="n">proton</span><span class="o">::</span><span class="n">value</span><span class="p">(</span><span class="s">"a"</span><span class="p">));</span>
+ <span class="n">vv</span><span class="p">.</span><span class="n">push_back</span><span class="p">(</span><span class="n">proton</span><span class="o">::</span><span class="n">value</span><span class="p">(</span><span class="s">"b"</span><span class="p">));</span>
+ <span class="n">vv</span><span class="p">.</span><span class="n">push_back</span><span class="p">(</span><span class="n">proton</span><span class="o">::</span><span class="n">value</span><span class="p">(</span><span class="s">"c"</span><span class="p">));</span>
+ <span class="n">v</span> <span class="o">=</span> <span class="n">vv</span><span class="p">;</span>
+ <span class="n">print</span><span class="p">(</span><span class="n">v</span><span class="p">);</span>
+<span class="p">}</span>
+
+<span class="c1">// Containers with mixed types use value to represent arbitrary AMQP types.</span>
+<span class="k">static</span> <span class="kt">void</span> <span class="n">mixed_containers</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span> <span class="o"><<</span> <span class="s">"== List and map of mixed type values."</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
+ <span class="n">proton</span><span class="o">::</span><span class="n">value</span> <span class="n">v</span><span class="p">;</span>
+
+ <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">proton</span><span class="o">::</span><span class="n">value</span><span class="o">></span> <span class="n">l</span><span class="p">;</span>
+ <span class="n">l</span><span class="p">.</span><span class="n">push_back</span><span class="p">(</span><span class="n">proton</span><span class="o">::</span><span class="n">value</span><span class="p">(</span><span class="mi">42</span><span class="p">));</span>
+ <span class="n">l</span><span class="p">.</span><span class="n">push_back</span><span class="p">(</span><span class="n">proton</span><span class="o">::</span><span class="n">value</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="p">(</span><span class="s">"foo"</span><span class="p">)));</span>
+ <span class="c1">// By default, a sequence of proton::value is treated as an AMQP list.</span>
+ <span class="n">v</span> <span class="o">=</span> <span class="n">l</span><span class="p">;</span>
+ <span class="n">print</span><span class="p">(</span><span class="n">v</span><span class="p">);</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">proton</span><span class="o">::</span><span class="n">value</span><span class="o">></span> <span class="n">l2</span> <span class="o">=</span> <span class="n">proton</span><span class="o">::</span><span class="n">get</span><span class="o"><</span><span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">proton</span><span class="o">::</span><span class="n">value</span><span class="o">></span> <span class="o">></span><span class="p">(</span><span class="n">v</span><span class="p">);</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="n">l2</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
+
+ <span class="n">std</span><span class="o">::</span><span class="n">map</span><span class="o"><</span><span class="n">proton</span><span class="o">::</span><span class="n">value</span><span class="p">,</span> <span class="n">proton</span><span class="o">::</span><span class="n">value</span><span class="o">></span> <span class="n">m</span><span class="p">;</span>
+ <span class="n">m</span><span class="p">[</span><span class="n">proton</span><span class="o">::</span><span class="n">value</span><span class="p">(</span><span class="s">"five"</span><span class="p">)]</span> <span class="o">=</span> <span class="n">proton</span><span class="o">::</span><span class="n">value</span><span class="p">(</span><span class="mi">5</span><span class="p">);</span>
+ <span class="n">m</span><span class="p">[</span><span class="n">proton</span><span class="o">::</span><span class="n">value</span><span class="p">(</span><span class="mi">4</span><span class="p">)]</span> <span class="o">=</span> <span class="n">proton</span><span class="o">::</span><span class="n">value</span><span class="p">(</span><span class="s">"four"</span><span class="p">);</span> <span class="n">v</span> <span class="o">=</span> <span class="n">m</span><span class="p">;</span>
+ <span class="n">print</span><span class="p">(</span><span class="n">v</span><span class="p">);</span>
+ <span class="k">typedef</span> <span class="n">std</span><span class="o">::</span><span class="n">map</span><span class="o"><</span><span class="n">proton</span><span class="o">::</span><span class="n">value</span><span class="p">,</span> <span class="n">proton</span><span class="o">::</span><span class="n">value</span><span class="o">></span> <span class="n">value_map</span><span class="p">;</span>
+ <span class="n">value_map</span> <span class="nf">m2</span><span class="p">(</span><span class="n">proton</span><span class="o">::</span><span class="n">get</span><span class="o"><</span><span class="n">value_map</span><span class="o">></span><span class="p">(</span><span class="n">v</span><span class="p">));</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="n">m2</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="c1">// Insert using stream operators (see print_next for example of extracting with stream ops.)</span>
+<span class="k">static</span> <span class="kt">void</span> <span class="n">insert_stream_operators</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span> <span class="o"><<</span> <span class="s">"== Insert with stream operators."</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
+ <span class="n">proton</span><span class="o">::</span><span class="n">value</span> <span class="n">v</span><span class="p">;</span>
+
+ <span class="c1">// Create an array of INT with values [1, 2, 3]</span>
+ <span class="n">proton</span><span class="o">::</span><span class="n">codec</span><span class="o">::</span><span class="n">encoder</span> <span class="n">e</span><span class="p">(</span><span class="n">v</span><span class="p">);</span>
+ <span class="n">e</span> <span class="o"><<</span> <span class="n">proton</span><span class="o">::</span><span class="n">codec</span><span class="o">::</span><span class="n">start</span><span class="o">::</span><span class="n">array</span><span class="p">(</span><span class="n">proton</span><span class="o">::</span><span class="n">INT</span><span class="p">)</span>
+ <span class="o"><<</span> <span class="kt">int32_t</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span> <span class="o"><<</span> <span class="kt">int32_t</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span> <span class="o"><<</span> <span class="kt">int32_t</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
+ <span class="o"><<</span> <span class="n">proton</span><span class="o">::</span><span class="n">codec</span><span class="o">::</span><span class="n">finish</span><span class="p">();</span>
+ <span class="n">print</span><span class="p">(</span><span class="n">v</span><span class="p">);</span>
+
+ <span class="c1">// Create a mixed-type list of the values [42, false, "x"].</span>
+ <span class="n">proton</span><span class="o">::</span><span class="n">codec</span><span class="o">::</span><span class="n">encoder</span> <span class="n">e2</span><span class="p">(</span><span class="n">v</span><span class="p">);</span>
+ <span class="n">e2</span> <span class="o"><<</span> <span class="n">proton</span><span class="o">::</span><span class="n">codec</span><span class="o">::</span><span class="n">start</span><span class="o">::</span><span class="n">list</span><span class="p">()</span>
+ <span class="o"><<</span> <span class="kt">int32_t</span><span class="p">(</span><span class="mi">42</span><span class="p">)</span> <span class="o"><<</span> <span class="nb">false</span> <span class="o"><<</span> <span class="n">proton</span><span class="o">::</span><span class="n">symbol</span><span class="p">(</span><span class="s">"x"</span><span class="p">)</span>
+ <span class="o"><<</span> <span class="n">proton</span><span class="o">::</span><span class="n">codec</span><span class="o">::</span><span class="n">finish</span><span class="p">();</span>
+ <span class="n">print</span><span class="p">(</span><span class="n">v</span><span class="p">);</span>
+
+ <span class="c1">// Create a map { "k1":42, "k2": false }</span>
+ <span class="n">proton</span><span class="o">::</span><span class="n">codec</span><span class="o">::</span><span class="n">encoder</span> <span class="n">e3</span><span class="p">(</span><span class="n">v</span><span class="p">);</span>
+ <span class="n">e3</span> <span class="o"><<</span> <span class="n">proton</span><span class="o">::</span><span class="n">codec</span><span class="o">::</span><span class="n">start</span><span class="o">::</span><span class="n">map</span><span class="p">()</span>
+ <span class="o"><<</span> <span class="s">"k1"</span> <span class="o"><<</span> <span class="kt">int32_t</span><span class="p">(</span><span class="mi">42</span><span class="p">)</span>
+ <span class="o"><<</span> <span class="n">proton</span><span class="o">::</span><span class="n">symbol</span><span class="p">(</span><span class="s">"k2"</span><span class="p">)</span> <span class="o"><<</span> <span class="nb">false</span>
+ <span class="o"><<</span> <span class="n">proton</span><span class="o">::</span><span class="n">codec</span><span class="o">::</span><span class="n">finish</span><span class="p">();</span>
+ <span class="n">print</span><span class="p">(</span><span class="n">v</span><span class="p">);</span>
+<span class="p">}</span>
+
+<span class="kt">int</span> <span class="n">main</span><span class="p">(</span><span class="kt">int</span><span class="p">,</span> <span class="kt">char</span><span class="o">**</span><span class="p">)</span> <span class="p">{</span>
+ <span class="k">try</span> <span class="p">{</span>
+ <span class="n">uniform_containers</span><span class="p">();</span>
+ <span class="n">mixed_containers</span><span class="p">();</span>
+ <span class="n">insert_stream_operators</span><span class="p">();</span>
+ <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+ <span class="p">}</span> <span class="k">catch</span> <span class="p">(</span><span class="k">const</span> <span class="n">std</span><span class="o">::</span><span class="n">exception</span><span class="o">&</span> <span class="n">e</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">cerr</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span> <span class="o"><<</span> <span class="s">"error: "</span> <span class="o"><<</span> <span class="n">e</span><span class="p">.</span><span class="n">what</span><span class="p">()</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
+ <span class="p">}</span>
+ <span class="k">return</span> <span class="mi">1</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="c1">// print_next prints the next value from values by recursively descending into complex values.</span>
+<span class="c1">//</span>
+<span class="c1">// NOTE this is for example puroses only: There is a built in ostream operator<< for values.</span>
+<span class="c1">//</span>
+<span class="c1">//</span>
+<span class="k">static</span> <span class="kt">void</span> <span class="n">print_next</span><span class="p">(</span><span class="n">proton</span><span class="o">::</span><span class="n">codec</span><span class="o">::</span><span class="n">decoder</span><span class="o">&</span> <span class="n">d</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">proton</span><span class="o">::</span><span class="n">type_id</span> <span class="n">type</span> <span class="o">=</span> <span class="n">d</span><span class="p">.</span><span class="n">next_type</span><span class="p">();</span>
+ <span class="n">proton</span><span class="o">::</span><span class="n">codec</span><span class="o">::</span><span class="n">start</span> <span class="n">s</span><span class="p">;</span>
+ <span class="k">switch</span> <span class="p">(</span><span class="n">type</span><span class="p">)</span> <span class="p">{</span>
+ <span class="k">case</span> <span class="n">proton</span><span class="o">::</span><span class="nl">ARRAY</span><span class="p">:</span> <span class="p">{</span>
+ <span class="n">d</span> <span class="o">>></span> <span class="n">s</span><span class="p">;</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"array<"</span> <span class="o"><<</span> <span class="n">s</span><span class="p">.</span><span class="n">element</span><span class="p">;</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">s</span><span class="p">.</span><span class="n">is_described</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">", descriptor="</span><span class="p">;</span>
+ <span class="n">print_next</span><span class="p">(</span><span class="n">d</span><span class="p">);</span>
+ <span class="p">}</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">">["</span><span class="p">;</span>
+ <span class="k">for</span> <span class="p">(</span><span class="kt">size_t</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">i</span> <span class="o"><</span> <span class="n">s</span><span class="p">.</span><span class="n">size</span><span class="p">;</span> <span class="o">++</span><span class="n">i</span><span class="p">)</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">i</span><span class="p">)</span> <span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">", "</span><span class="p">;</span>
+ <span class="n">print_next</span><span class="p">(</span><span class="n">d</span><span class="p">);</span>
+ <span class="p">}</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"]"</span><span class="p">;</span>
+ <span class="n">d</span> <span class="o">>></span> <span class="n">proton</span><span class="o">::</span><span class="n">codec</span><span class="o">::</span><span class="n">finish</span><span class="p">();</span>
+ <span class="k">break</span><span class="p">;</span>
+ <span class="p">}</span>
+ <span class="k">case</span> <span class="n">proton</span><span class="o">::</span><span class="nl">LIST</span><span class="p">:</span> <span class="p">{</span>
+ <span class="n">d</span> <span class="o">>></span> <span class="n">s</span><span class="p">;</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"list["</span><span class="p">;</span>
+ <span class="k">for</span> <span class="p">(</span><span class="kt">size_t</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">i</span> <span class="o"><</span> <span class="n">s</span><span class="p">.</span><span class="n">size</span><span class="p">;</span> <span class="o">++</span><span class="n">i</span><span class="p">)</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">i</span><span class="p">)</span> <span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">", "</span><span class="p">;</span>
+ <span class="n">print_next</span><span class="p">(</span><span class="n">d</span><span class="p">);</span>
+ <span class="p">}</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"]"</span><span class="p">;</span>
+ <span class="n">d</span> <span class="o">>></span> <span class="n">proton</span><span class="o">::</span><span class="n">codec</span><span class="o">::</span><span class="n">finish</span><span class="p">();</span>
+ <span class="k">break</span><span class="p">;</span>
+ <span class="p">}</span>
+ <span class="k">case</span> <span class="n">proton</span><span class="o">::</span><span class="nl">MAP</span><span class="p">:</span> <span class="p">{</span>
+ <span class="n">d</span> <span class="o">>></span> <span class="n">s</span><span class="p">;</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"map{"</span><span class="p">;</span>
+ <span class="k">for</span> <span class="p">(</span><span class="kt">size_t</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">i</span> <span class="o"><</span> <span class="n">s</span><span class="p">.</span><span class="n">size</span><span class="o">/</span><span class="mi">2</span><span class="p">;</span> <span class="o">++</span><span class="n">i</span><span class="p">)</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">i</span><span class="p">)</span> <span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">", "</span><span class="p">;</span>
+ <span class="n">print_next</span><span class="p">(</span><span class="n">d</span><span class="p">);</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">":"</span><span class="p">;</span> <span class="c1">// key:value</span>
+ <span class="n">print_next</span><span class="p">(</span><span class="n">d</span><span class="p">);</span>
+ <span class="p">}</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"}"</span><span class="p">;</span>
+ <span class="n">d</span> <span class="o">>></span> <span class="n">proton</span><span class="o">::</span><span class="n">codec</span><span class="o">::</span><span class="n">finish</span><span class="p">();</span>
+ <span class="k">break</span><span class="p">;</span>
+ <span class="p">}</span>
+ <span class="k">case</span> <span class="n">proton</span><span class="o">::</span><span class="nl">DESCRIBED</span><span class="p">:</span> <span class="p">{</span>
+ <span class="n">d</span> <span class="o">>></span> <span class="n">s</span><span class="p">;</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"described("</span><span class="p">;</span>
+ <span class="n">print_next</span><span class="p">(</span><span class="n">d</span><span class="p">);</span> <span class="c1">// Descriptor</span>
+ <span class="n">print_next</span><span class="p">(</span><span class="n">d</span><span class="p">);</span> <span class="c1">// value</span>
+ <span class="n">d</span> <span class="o">>></span> <span class="n">proton</span><span class="o">::</span><span class="n">codec</span><span class="o">::</span><span class="n">finish</span><span class="p">();</span>
+ <span class="k">break</span><span class="p">;</span>
+ <span class="p">}</span>
+ <span class="k">default</span><span class="o">:</span>
+ <span class="c1">// A simple type. We could continue the switch for all AMQP types but</span>
+ <span class="c1">// we will take a short cut and extract to another value and print that.</span>
+ <span class="n">proton</span><span class="o">::</span><span class="n">value</span> <span class="n">v2</span><span class="p">;</span>
+ <span class="n">d</span> <span class="o">>></span> <span class="n">v2</span><span class="p">;</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="n">type</span> <span class="o"><<</span> <span class="s">"("</span> <span class="o"><<</span> <span class="n">v2</span> <span class="o"><<</span> <span class="s">")"</span><span class="p">;</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+
+<span class="c1">// Print a value, for example purposes. Normal code can use operator<<</span>
+<span class="kt">void</span> <span class="n">print</span><span class="p">(</span><span class="n">proton</span><span class="o">::</span><span class="n">value</span><span class="o">&</span> <span class="n">v</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">proton</span><span class="o">::</span><span class="n">codec</span><span class="o">::</span><span class="n">decoder</span> <span class="n">d</span><span class="p">(</span><span class="n">v</span><span class="p">);</span>
+ <span class="n">d</span><span class="p">.</span><span class="n">rewind</span><span class="p">();</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">boolalpha</span><span class="p">;</span> <span class="c1">// Print boolean as true/false.</span>
+ <span class="k">while</span> <span class="p">(</span><span class="n">d</span><span class="p">.</span><span class="n">more</span><span class="p">())</span> <span class="p">{</span>
+ <span class="n">print_next</span><span class="p">(</span><span class="n">d</span><span class="p">);</span>
+ <span class="k">if</span> <span class="p">(</span><span class="n">d</span><span class="p">.</span><span class="n">more</span><span class="p">())</span> <span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">", "</span><span class="p">;</span>
+ <span class="p">}</span>
+ <span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
+<span class="p">}</span>
+</pre></div>
+
+<p><a href="encode_decode.cpp">Download this file</a></p>
http://git-wip-us.apache.org/repos/asf/qpid-site/blob/75ca8b14/input/releases/qpid-proton-0.13.0/proton/cpp/examples/fake_cpp11.hpp
----------------------------------------------------------------------
diff --git a/input/releases/qpid-proton-0.13.0/proton/cpp/examples/fake_cpp11.hpp b/input/releases/qpid-proton-0.13.0/proton/cpp/examples/fake_cpp11.hpp
new file mode 100644
index 0000000..03daa3b
--- /dev/null
+++ b/input/releases/qpid-proton-0.13.0/proton/cpp/examples/fake_cpp11.hpp
@@ -0,0 +1,34 @@
+#ifndef FAKE_CPP11_HPP
+#define FAKE_CPP11_HPP
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+/// These definitions allow us to use some new C++11 features in previous compilers
+///
+/// It is strongly recommended not to copy this - just use C++11/C++14 instead!
+
+#if __cplusplus < 201103L
+#define OVERRIDE
+#else
+#define OVERRIDE override
+#endif
+
+
+#endif // FAKE_CPP11_HPP
http://git-wip-us.apache.org/repos/asf/qpid-site/blob/75ca8b14/input/releases/qpid-proton-0.13.0/proton/cpp/examples/fake_cpp11.hpp.html.in
----------------------------------------------------------------------
diff --git a/input/releases/qpid-proton-0.13.0/proton/cpp/examples/fake_cpp11.hpp.html.in b/input/releases/qpid-proton-0.13.0/proton/cpp/examples/fake_cpp11.hpp.html.in
new file mode 100644
index 0000000..45258cb
--- /dev/null
+++ b/input/releases/qpid-proton-0.13.0/proton/cpp/examples/fake_cpp11.hpp.html.in
@@ -0,0 +1,22 @@
+
+<h1>fake_cpp11.hpp</h1>
+<div class="highlight"><pre><span></span><span class="cp">#ifndef FAKE_CPP11_HPP</span>
+<span class="cp">#define FAKE_CPP11_HPP</span>
+
+
+
+<span class="c1">/// These definitions allow us to use some new C++11 features in previous compilers</span>
+<span class="c1">///</span>
+<span class="c1">/// It is strongly recommended not to copy this - just use C++11/C++14 instead!</span>
+
+<span class="cp">#if __cplusplus < 201103L</span>
+<span class="cp">#define OVERRIDE</span>
+<span class="cp">#else</span>
+<span class="cp">#define OVERRIDE override</span>
+<span class="cp">#endif</span>
+
+
+<span class="cp">#endif </span><span class="c1">// FAKE_CPP11_HPP</span>
+</pre></div>
+
+<p><a href="fake_cpp11.hpp">Download this file</a></p>
http://git-wip-us.apache.org/repos/asf/qpid-site/blob/75ca8b14/input/releases/qpid-proton-0.13.0/proton/cpp/examples/flow_control.cpp
----------------------------------------------------------------------
diff --git a/input/releases/qpid-proton-0.13.0/proton/cpp/examples/flow_control.cpp b/input/releases/qpid-proton-0.13.0/proton/cpp/examples/flow_control.cpp
new file mode 100644
index 0000000..2eedd65
--- /dev/null
+++ b/input/releases/qpid-proton-0.13.0/proton/cpp/examples/flow_control.cpp
@@ -0,0 +1,233 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ */
+
+#include <proton/listener.hpp>
+#include <proton/connection.hpp>
+#include <proton/connection_options.hpp>
+#include <proton/default_container.hpp>
+#include <proton/messaging_handler.hpp>
+#include <proton/sender.hpp>
+#include <proton/tracker.hpp>
+#include <proton/delivery.hpp>
+
+#include <iostream>
+#include <sstream>
+
+#include "fake_cpp11.hpp"
+
+namespace {
+
+bool verbose = true;
+
+void verify(bool success, const std::string &msg) {
+ if (!success)
+ throw std::runtime_error("example failure:" + msg);
+ else {
+ std::cout << "success: " << msg << std::endl;
+ if (verbose) std::cout << std::endl;
+ }
+}
+
+}
+
+// flow_sender manages the incoming connection and acts as the message sender.
+class flow_sender : public proton::messaging_handler {
+ private:
+ int available; // Number of messages the sender may send assuming sufficient credit.
+ int sequence;
+
+ public:
+ flow_sender() : available(0), sequence(0) {}
+
+ void on_sendable(proton::sender &s) OVERRIDE {
+ if (verbose)
+ std::cout << "flow_sender in \"on_sendable\" with credit " << s.credit()
+ << " and " << available << " available messages" << std::endl;
+ for (int i = sequence; available && s.credit() > 0; i++) {
+ std::ostringstream mbody;
+ mbody << "flow_sender message " << sequence++;
+ proton::message m(mbody.str());
+ s.send(m);
+ available--;
+ }
+ }
+
+ void on_sender_drain_start(proton::sender &s) OVERRIDE {
+ if (verbose)
+ std::cout << "flow_sender in \"on_drain_start\" with credit " << s.credit()
+ << " making an internal call to \"on_sendble\"" << std::endl;
+ on_sendable(s); // send as many as we can
+ if (s.credit()) {
+ s.return_credit(); // return the rest
+ }
+ }
+
+ void set_available(int n) { available = n; }
+};
+
+class flow_receiver : public proton::messaging_handler {
+ public:
+ int stage;
+ int received;
+ flow_sender &sender;
+
+ flow_receiver(flow_sender &s) : stage(0), sender(s) {}
+
+ void example_setup(int n) {
+ received = 0;
+ sender.set_available(n);
+ }
+
+ void run_stage(proton::receiver &r, const std::string &caller) {
+ // Serialize the progression of the flow control examples.
+ switch (stage) {
+ case 0:
+ if (verbose) std::cout << "Example 1. Simple use of credit." << std::endl;
+ // TODO: add timeout callbacks, show no messages until credit.
+ example_setup(2);
+ r.add_credit(2);
+ break;
+ case 1:
+ if (r.credit() > 0) return;
+ verify(received == 2, "Example 1: simple credit");
+
+ if (verbose) std::cout << "Example 2. Use basic drain, sender has 3 \"immediate\" messages." << std::endl;
+ example_setup(3);
+ r.add_credit(5); // ask for up to 5
+ r.drain(); // but only use what's available
+ break;
+ case 2:
+ if (caller == "on_message") return;
+ if (caller == "on_receiver_drain_finish") {
+ // Note that unused credit of 2 at sender is returned and is now 0.
+ verify(received == 3 && r.credit() == 0, "Example 2: basic drain");
+
+ if (verbose) std::cout << "Example 3. Drain use with no credit." << std::endl;
+ example_setup(0);
+ r.drain();
+ break;
+ }
+ verify(false, "example 2 run_stage");
+ return;
+
+ case 3:
+ verify(caller == "on_receiver_drain_finish" && received == 0, "Example 3: drain without credit");
+
+ if (verbose) std::cout << "Example 4. Show using high(10)/low(3) watermark for 25 messages." << std::endl;
+ example_setup(25);
+ r.add_credit(10);
+ break;
+
+ case 4:
+ if (received < 25) {
+ // Top up credit as needed.
+ uint32_t credit = r.credit();
+ if (credit <= 3) {
+ uint32_t new_credit = 10;
+ uint32_t remaining = 25 - received;
+ if (new_credit > remaining)
+ new_credit = remaining;
+ if (new_credit > credit) {
+ r.add_credit(new_credit - credit);
+ if (verbose)
+ std::cout << "flow_receiver adding credit for " << new_credit - credit
+ << " messages" << std::endl;
+ }
+ }
+ return;
+ }
+
+ verify(received == 25 && r.credit() == 0, "Exmaple 4: high/low watermark");
+ r.connection().close();
+ break;
+
+ default:
+ throw std::runtime_error("run_stage sequencing error");
+ }
+ stage++;
+ }
+
+ void on_receiver_open(proton::receiver &r) OVERRIDE {
+ run_stage(r, "on_receiver_open");
+ }
+
+ void on_message(proton::delivery &d, proton::message &m) OVERRIDE {
+ if (verbose)
+ std::cout << "flow_receiver in \"on_message\" with " << m.body() << std::endl;
+ proton::receiver r(d.receiver());
+ received++;
+ run_stage(r, "on_message");
+ }
+
+ void on_receiver_drain_finish(proton::receiver &r) OVERRIDE {
+ if (verbose)
+ std::cout << "flow_receiver in \"on_receiver_drain_finish\"" << std::endl;
+ run_stage(r, "on_receiver_drain_finish");
+ }
+};
+
+
+class flow_control : public proton::messaging_handler {
+ private:
+ std::string url;
+ proton::listener listener;
+ flow_sender send_handler;
+ flow_receiver receive_handler;
+
+ public:
+ flow_control(const std::string& u) : url(u), receive_handler(send_handler) {}
+
+ void on_container_start(proton::container &c) OVERRIDE {
+ listener = c.listen(url, proton::connection_options().handler(send_handler));
+ c.connect(url);
+ }
+
+ void on_connection_open(proton::connection &c) OVERRIDE {
+ if (c.active()) {
+ // outbound connection
+ c.open_receiver("flow_example", proton::receiver_options().handler(receive_handler).credit_window(0));
+ }
+ }
+
+ void on_connection_close(proton::connection &) OVERRIDE {
+ listener.stop();
+ }
+};
+
+int main(int argc, char **argv) {
+ std::string quiet_arg("-quiet");
+ if (argc > 2 && quiet_arg == argv[2])
+ verbose = false;
+ try {
+ // Pick an "unusual" port since we are going to be talking to
+ // ourselves, not a broker.
+ std::string url = argc > 1 ? argv[1] : "127.0.0.1:8888/examples";
+
+ flow_control fc(url);
+ proton::default_container(fc).run();
+
+ return 0;
+ } catch (const std::exception& e) {
+ std::cerr << e.what() << std::endl;
+ }
+
+ return 1;
+}
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@qpid.apache.org
For additional commands, e-mail: commits-help@qpid.apache.org