1 files changed, 178 insertions, 0 deletions
diff --git a/cpp/examples/examples/request-response/client.cpp b/cpp/examples/examples/request-response/client.cpp
new file mode 100644
index 0000000000..59024a1cb6
--- /dev/null
+++ b/cpp/examples/examples/request-response/client.cpp
@@ -0,0 +1,178 @@
+/*
+ *
+ * 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.
+ *
+ */
+
+
+/**
+ *  client.cpp
+ *
+ *  This program is one of two programs that illustrate the
+ *  request/response pattern.
+ *  
+ *    client.cpp (this program)
+ *
+ *      Make requests of a service, print the response.
+ *
+ *    service.cpp
+ *
+ *      Accept requests, reverse the letters in each message, and
+ *      return it as a response.
+ *
+ */
+
+
+#include <qpid/client/Connection.h>
+#include <qpid/client/Dispatcher.h>
+#include <qpid/client/Session.h>
+#include <qpid/client/Message.h>
+#include <qpid/client/MessageListener.h>
+
+#include <unistd.h>
+#include <cstdlib>
+#include <iostream>
+
+#include <sstream>
+
+using namespace qpid::client;
+using namespace qpid::framing;
+
+class Listener : public MessageListener{
+private:
+  Session session;
+  std::string destination_name;
+  Dispatcher dispatcher;
+  int counter;
+public:
+  Listener(Session& session, string destination_name): 
+    destination_name(destination_name),
+    dispatcher(session),
+    session(session),
+    counter(0)
+  {};
+
+  virtual void listen();
+  virtual void wait();
+  virtual void received(Message& message);
+  ~Listener() { };
+};
+
+
+void Listener::listen() {
+  std::cout << "Activating response queue listener for: " <<destination_name << std::endl;
+
+  session.messageSubscribe(arg::queue=destination_name, arg::destination=destination_name);
+
+    // Allocate credit. Sigh. This really should not be required #####
+  session.messageFlow(arg::destination=destination_name, arg::unit=0, arg::value=1);//messages ### Define a constant?
+  session.messageFlow(arg::destination=destination_name, arg::unit=1, arg::value=0xFFFFFFFF);//bytes ###### Define a constant?
+
+
+  dispatcher.listen(destination_name, this);
+}
+
+
+void Listener::wait() {
+  std::cout << "Waiting for all responses to arrive ..." << std::endl;
+  dispatcher.run();
+}
+
+
+void Listener::received(Message& message) {
+  std::cout << "Response: " << message.getData() << std::endl;
+
+  ++ counter;
+  if (counter > 3) {
+      std::cout << "Shutting down listener for " << destination_name << std::endl;
+      dispatcher.stop();
+  }
+}
+
+
+using std::stringstream;
+using std::string;
+
+int main() {
+    Connection connection;
+    Message request;
+    try {
+        connection.open("127.0.0.1", 5672 );
+        Session session =  connection.newSession();
+
+  //--------- Main body of program --------------------------------------------
+
+	// Create a response queue so the server can send us responses
+	// to our requests. Use the client's session ID as the name
+	// of the response queue.
+
+	stringstream response_queue;
+	response_queue << "client " << session.getId();
+
+        // Use the name of the response queue as the routing key
+
+	session.queueDeclare(arg::queue=response_queue.str());  // ### Nice if I could just use strstream for this
+        session.queueBind(arg::queue=response_queue.str(), arg::routingKey=response_queue.str());
+
+	// Create a listener for the response queue and start listening.
+
+	Listener listener(session, response_queue.str());
+	listener.listen();
+
+
+	// The routing key for the request queue is simply
+	// "request_queue", and all clients use the same routing key.
+	//
+	// Each client sends the name of their own response queue so
+	// the service knows where to route messages.
+
+	request.getDeliveryProperties().setRoutingKey("request_queue");
+	request.getHeaders().setString("reply-to", response_queue.str());
+
+	// Now send some requests ...
+
+	string s[] = {
+		"Twas brillig, and the slithy toves",
+		"Did gire and gymble in the wabe.",
+		"All mimsy were the borogroves,",
+		"And the mome raths outgrabe."
+        };
+
+
+	for (int i=0; i<4; i++) {
+	  request.setData(s[i]);
+          session.messageTransfer(arg::content=request);
+	  std::cout << "Request: " << s[i] << std::endl;
+	}
+
+	// And wait for any outstanding responses to arrive
+
+	listener.wait();
+	
+
+  //-----------------------------------------------------------------------------
+
+        connection.close();
+        return 0;
+    } catch(const std::exception& error) {
+        std::cout << error.what() << std::endl;
+    }
+    return 1;
+}
+
+