qpid-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From astitc...@apache.org
Subject qpid-proton git commit: PROTON-1372: [C++ binding] Pimpl event_loop - To make sure that we maintain C++03/C++11 cross compatibility.
Date Thu, 08 Dec 2016 09:00:59 GMT
Repository: qpid-proton
Updated Branches:
  refs/heads/master bea617333 -> f89d24d85


PROTON-1372: [C++ binding] Pimpl event_loop
- To make sure that we maintain C++03/C++11 cross compatibility.


Project: http://git-wip-us.apache.org/repos/asf/qpid-proton/repo
Commit: http://git-wip-us.apache.org/repos/asf/qpid-proton/commit/f89d24d8
Tree: http://git-wip-us.apache.org/repos/asf/qpid-proton/tree/f89d24d8
Diff: http://git-wip-us.apache.org/repos/asf/qpid-proton/diff/f89d24d8

Branch: refs/heads/master
Commit: f89d24d855fe684d97ef640235a04afdbb08c885
Parents: bea6173
Author: Andrew Stitcher <astitcher@apache.org>
Authored: Thu Dec 8 03:25:57 2016 -0500
Committer: Andrew Stitcher <astitcher@apache.org>
Committed: Thu Dec 8 03:49:58 2016 -0500

----------------------------------------------------------------------
 .../bindings/cpp/include/proton/event_loop.hpp  | 38 ++++++++++++++-----
 .../cpp/include/proton/internal/config.hpp      |  4 ++
 .../cpp/include/proton/internal/object.hpp      |  2 +-
 .../cpp/include/proton/io/connection_driver.hpp |  5 ++-
 .../bindings/cpp/include/proton/thread_safe.hpp | 23 ++++++------
 proton-c/bindings/cpp/src/container_impl.cpp    | 27 ++++++--------
 proton-c/bindings/cpp/src/event_loop.cpp        | 28 +++++++++++---
 proton-c/bindings/cpp/src/include/contexts.hpp  |  2 +-
 .../cpp/src/include/event_loop_impl.hpp         | 39 ++++++++++++++++++++
 .../bindings/cpp/src/io/connection_driver.cpp   | 12 +++++-
 proton-c/bindings/cpp/src/thread_safe_test.cpp  |  4 +-
 11 files changed, 135 insertions(+), 49 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/f89d24d8/proton-c/bindings/cpp/include/proton/event_loop.hpp
----------------------------------------------------------------------
diff --git a/proton-c/bindings/cpp/include/proton/event_loop.hpp b/proton-c/bindings/cpp/include/proton/event_loop.hpp
index d43ba4f..f49d211 100644
--- a/proton-c/bindings/cpp/include/proton/event_loop.hpp
+++ b/proton-c/bindings/cpp/include/proton/event_loop.hpp
@@ -25,6 +25,7 @@
 #include "./fwd.hpp"
 #include "./internal/config.hpp"
 #include "./internal/export.hpp"
+#include "./internal/pn_unique_ptr.hpp"
 
 #include <functional>
 
@@ -41,31 +42,48 @@ namespace proton {
 /// and have it executed in the same sequence.
 ///
 class PN_CPP_CLASS_EXTERN event_loop {
+    /// @cond internal
+    class impl;
+    event_loop& operator=(impl* i);
+    /// @endcond
+
   public:
-    virtual ~event_loop() {}
+    /// Create event_loop
+    PN_CPP_EXTERN event_loop();
+
+    PN_CPP_EXTERN ~event_loop();
+
+#if PN_CPP_HAS_EXPLICIT_CONVERSIONS
+    /// When using C++11 (or later) you can use event_loop in a bool context
+    /// to indicate if there is an event loop set.
+    PN_CPP_EXTERN explicit operator bool() const { return bool(impl_); }
+#endif
+
+    /// No event loop set.
+    PN_CPP_EXTERN bool operator !() const { return !impl_; }
 
     /// Arrange to have f() called in the event_loop's sequence: possibly
     /// deferred, possibly in another thread.
     ///
     /// @return true if f() has or will be called, false if the event_loop is ended
     /// and f() cannot be injected.
-    virtual bool inject(void_function0& f) = 0;
+    PN_CPP_EXTERN bool inject(void_function0& f);
 
 #if PN_CPP_HAS_STD_FUNCTION
     /// @copydoc inject(void_function0&)
-    virtual bool inject(std::function<void()> f) = 0;
+    PN_CPP_EXTERN bool inject(std::function<void()> f);
 #endif
 
-  protected:
-    event_loop() {}
-
   private:
-    PN_CPP_EXTERN static event_loop* get(pn_connection_t*);
-    PN_CPP_EXTERN static event_loop* get(pn_session_t*);
-    PN_CPP_EXTERN static event_loop* get(pn_link_t*);
+    PN_CPP_EXTERN static event_loop& get(pn_connection_t*);
+    PN_CPP_EXTERN static event_loop& get(pn_session_t*);
+    PN_CPP_EXTERN static event_loop& get(pn_link_t*);
+
+    internal::pn_unique_ptr<impl> impl_;
 
     /// @cond INTERNAL
-  friend class connection;
+  friend class container;
+  friend class io::connection_driver;
   template <class T> friend class thread_safe;
     /// @endcond
 };

http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/f89d24d8/proton-c/bindings/cpp/include/proton/internal/config.hpp
----------------------------------------------------------------------
diff --git a/proton-c/bindings/cpp/include/proton/internal/config.hpp b/proton-c/bindings/cpp/include/proton/internal/config.hpp
index 612e1e3..563a304 100644
--- a/proton-c/bindings/cpp/include/proton/internal/config.hpp
+++ b/proton-c/bindings/cpp/include/proton/internal/config.hpp
@@ -87,6 +87,10 @@
 #define PN_CPP_HAS_STD_FUNCTION PN_CPP_HAS_CPP11
 #endif
 
+#ifndef PN_CPP_HAS_STD_BIND
+#define PN_CPP_HAS_STD_BIND PN_CPP_HAS_CPP11
+#endif
+
 #ifndef PN_CPP_HAS_CHRONO
 #define PN_CPP_HAS_CHRONO PN_CPP_HAS_CPP11
 #endif

http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/f89d24d8/proton-c/bindings/cpp/include/proton/internal/object.hpp
----------------------------------------------------------------------
diff --git a/proton-c/bindings/cpp/include/proton/internal/object.hpp b/proton-c/bindings/cpp/include/proton/internal/object.hpp
index 78a990c..d492b80 100644
--- a/proton-c/bindings/cpp/include/proton/internal/object.hpp
+++ b/proton-c/bindings/cpp/include/proton/internal/object.hpp
@@ -101,7 +101,7 @@ template <class T> class object : private comparable<object<T>
> {
     friend bool operator==(const object& a, const object& b) { return a.object_ ==
b.object_; }
     friend bool operator<(const object& a, const object& b) { return a.object_
< b.object_; }
     friend std::ostream& operator<<(std::ostream& o, const object& a) {
o << a.object_.inspect(); return o; }
-  template <class U> friend class proton::thread_safe;
+    template <class U> friend class proton::thread_safe;
 };
 
 /// Factory class used internally to make wrappers and extract proton objects

http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/f89d24d8/proton-c/bindings/cpp/include/proton/io/connection_driver.hpp
----------------------------------------------------------------------
diff --git a/proton-c/bindings/cpp/include/proton/io/connection_driver.hpp b/proton-c/bindings/cpp/include/proton/io/connection_driver.hpp
index d5da718..4a0efe9 100644
--- a/proton-c/bindings/cpp/include/proton/io/connection_driver.hpp
+++ b/proton-c/bindings/cpp/include/proton/io/connection_driver.hpp
@@ -111,7 +111,10 @@ PN_CPP_CLASS_EXTERN connection_driver {
     /// the user pins it in memory using the proton::thread_safe<> template.
     /// The event_loop is deleted when, and only when, the proton::connection is.
     ///
-    PN_CPP_EXTERN connection_driver(proton::container&, event_loop* loop = 0);
+    PN_CPP_EXTERN connection_driver(proton::container&);
+#if PN_CPP_HAS_RVALUE_REFERENCES
+    PN_CPP_EXTERN connection_driver(proton::container&, event_loop&& loop);
+#endif
 
     PN_CPP_EXTERN ~connection_driver();
 

http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/f89d24d8/proton-c/bindings/cpp/include/proton/thread_safe.hpp
----------------------------------------------------------------------
diff --git a/proton-c/bindings/cpp/include/proton/thread_safe.hpp b/proton-c/bindings/cpp/include/proton/thread_safe.hpp
index 28aa3a6..608a1ca 100644
--- a/proton-c/bindings/cpp/include/proton/thread_safe.hpp
+++ b/proton-c/bindings/cpp/include/proton/thread_safe.hpp
@@ -43,8 +43,6 @@ template<> struct endpoint_traits<sender> {};
 template<> struct endpoint_traits<receiver> {};
 }
 
-template <class T> class returned;
-
 /// **Experimental** - A thread-safe object wrapper.
 ///
 /// The proton::object subclasses (proton::connection, proton::sender etc.) are
@@ -78,11 +76,11 @@ class thread_safe : private internal::pn_ptr_base, private internal::endpoint_tr
 
     ~thread_safe() {
         if (ptr()) {
-            if (event_loop()) {
-#if PN_CPP_HAS_CPP11
-                event_loop()->inject(std::bind(&decref, ptr()));
+            if (!!event_loop()) {
+#if PN_CPP_HAS_STD_BIND
+                event_loop().inject(std::bind(&decref, ptr()));
 #else
-                event_loop()->inject(*new inject_decref(ptr()));
+                event_loop().inject(*new inject_decref(ptr()));
 #endif
             } else {
                 decref(ptr());
@@ -91,7 +89,7 @@ class thread_safe : private internal::pn_ptr_base, private internal::endpoint_tr
     }
 
     /// Get the event loop for this object.
-    class event_loop* event_loop() { return event_loop::get(ptr()); }
+    class event_loop& event_loop() { return event_loop::get(ptr()); }
 
     /// Get the thread-unsafe proton object wrapped by this thread_safe<T>
     T unsafe() { return T(ptr()); }
@@ -140,12 +138,13 @@ class returned : private internal::endpoint_traits<T>
     /// Implicit conversion to target, usable only in a safe context.
     operator T() { return ptr_->unsafe(); }
 
-#if PN_CPP_HAS_CPP11
+#if PN_CPP_HAS_SHARED_PTR
     /// Release to a std::shared_ptr
     operator std::shared_ptr<thread_safe<T> >() {
         return std::shared_ptr<thread_safe<T> >(release());
     }
-
+#endif
+#if PN_CPP_HAS_UNIQUE_PTR
     /// Release to a std::unique_ptr
     operator std::unique_ptr<thread_safe<T> >() {
         return std::unique_ptr<thread_safe<T> >(release());
@@ -160,13 +159,13 @@ class returned : private internal::endpoint_traits<T>
 /// Make a thread-safe wrapper for `obj`.
 template <class T> returned<T> make_thread_safe(const T& obj) { return returned<T>(obj);
}
 
-#if PN_CPP_HAS_CPP11
-
+#if PN_CPP_HAS_SHARED_PTR
 /// Create a thread-safe shared_ptr to `obj`.
 template <class T> std::shared_ptr<thread_safe<T> > make_shared_thread_safe(const
T& obj) {
     return make_thread_safe(obj);
 }
-
+#endif
+#if PN_CPP_HAS_UNIQUE_PTR
 /// Create a thread-safe unique_ptr to `obj`.
 template <class T> std::unique_ptr<thread_safe<T> > make_unique_thread_safe(const
T& obj) {
     return make_thread_safe(obj);

http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/f89d24d8/proton-c/bindings/cpp/src/container_impl.cpp
----------------------------------------------------------------------
diff --git a/proton-c/bindings/cpp/src/container_impl.cpp b/proton-c/bindings/cpp/src/container_impl.cpp
index 5f13b82..9cec831 100644
--- a/proton-c/bindings/cpp/src/container_impl.cpp
+++ b/proton-c/bindings/cpp/src/container_impl.cpp
@@ -38,6 +38,7 @@
 #include "connector.hpp"
 #include "container_impl.hpp"
 #include "contexts.hpp"
+#include "event_loop_impl.hpp"
 #include "messaging_adapter.hpp"
 #include "msg.hpp"
 #include "proton_bits.hpp"
@@ -160,24 +161,20 @@ container::impl::~impl() {
         close_acceptor(i->second);
 }
 
-namespace {
 // FIXME aconway 2016-06-07: this is not thread safe. It is sufficient for using
 // default_container::schedule() inside a handler but not for inject() from
 // another thread.
-struct immediate_event_loop : public event_loop {
-    virtual bool inject(void_function0& f) PN_CPP_OVERRIDE {
-        try { f(); } catch(...) {}
-        return true;
-    }
+bool event_loop::impl::inject(void_function0& f) {
+    try { f(); } catch(...) {}
+    return true;
+}
 
-#if PN_CPP_HAS_CPP11
-    virtual bool inject(std::function<void()> f) PN_CPP_OVERRIDE {
-        try { f(); } catch(...) {}
-        return true;
-    }
-#endif
-};
+#if PN_CPP_HAS_STD_FUNCTION
+bool event_loop::impl::inject(std::function<void()> f) {
+    try { f(); } catch(...) {}
+    return true;
 }
+#endif
 
 returned<connection> container::impl::connect(const std::string &urlstr, const
connection_options &user_opts) {
     connection_options opts = client_connection_options(); // Defaults
@@ -195,7 +192,7 @@ returned<connection> container::impl::connect(const std::string
&urlstr, const c
     internal::pn_unique_ptr<connector> ctor(new connector(conn, opts, url));
     connection_context& cc(connection_context::get(conn));
     cc.handler.reset(ctor.release());
-    cc.event_loop.reset(new immediate_event_loop);
+    cc.event_loop_ = new event_loop::impl;
 
     pn_connection_t *pnc = unwrap(conn);
     pn_connection_set_container(pnc, id_.c_str());
@@ -347,7 +344,7 @@ void container::impl::configure_server_connection(connection &c) {
         pn_record_t *record = pn_connection_attachments(unwrap(c));
         pn_record_set_handler(record, chandler.get());
     }
-    connection_context::get(c).event_loop.reset(new immediate_event_loop);
+    connection_context::get(c).event_loop_ = new event_loop::impl;
 }
 
 void container::impl::run() {

http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/f89d24d8/proton-c/bindings/cpp/src/event_loop.cpp
----------------------------------------------------------------------
diff --git a/proton-c/bindings/cpp/src/event_loop.cpp b/proton-c/bindings/cpp/src/event_loop.cpp
index 3d373c4..ea4ee71 100644
--- a/proton-c/bindings/cpp/src/event_loop.cpp
+++ b/proton-c/bindings/cpp/src/event_loop.cpp
@@ -17,24 +17,40 @@
  * under the License.
  */
 
+#include "proton/event_loop.hpp"
+
 #include "contexts.hpp"
+#include "event_loop_impl.hpp"
 
 #include <proton/session.h>
 #include <proton/link.h>
 
-#include "proton/event_loop.hpp"
-
 namespace proton {
 
-event_loop* event_loop::get(pn_connection_t* c) {
-    return connection_context::get(c).event_loop.get();
+event_loop::event_loop() {}
+event_loop::~event_loop() {}
+
+event_loop& event_loop::operator=(impl* i) { impl_.reset(i); return *this; }
+
+bool event_loop::inject(void_function0& f) {
+    return impl_->inject(f);
+}
+
+#if PN_CPP_HAS_STD_FUNCTION
+bool event_loop::inject(std::function<void()> f) {
+    return impl_->inject(f);
+}
+#endif
+
+event_loop& event_loop::get(pn_connection_t* c) {
+    return connection_context::get(c).event_loop_;
 }
 
-event_loop* event_loop::get(pn_session_t* s) {
+event_loop& event_loop::get(pn_session_t* s) {
     return get(pn_session_connection(s));
 }
 
-event_loop* event_loop::get(pn_link_t* l) {
+event_loop& event_loop::get(pn_link_t* l) {
     return get(pn_link_session(l));
 }
 

http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/f89d24d8/proton-c/bindings/cpp/src/include/contexts.hpp
----------------------------------------------------------------------
diff --git a/proton-c/bindings/cpp/src/include/contexts.hpp b/proton-c/bindings/cpp/src/include/contexts.hpp
index 4306489..e80c434 100644
--- a/proton-c/bindings/cpp/src/include/contexts.hpp
+++ b/proton-c/bindings/cpp/src/include/contexts.hpp
@@ -93,7 +93,7 @@ class connection_context : public context {
     io::link_namer* link_gen;      // Link name generator.
 
     internal::pn_unique_ptr<proton_handler> handler;
-    internal::pn_unique_ptr<class event_loop> event_loop;
+    event_loop event_loop_;
 
     static connection_context& get(pn_connection_t *c) { return ref<connection_context>(id(c));
}
     static connection_context& get(const connection& c) { return ref<connection_context>(id(c));
}

http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/f89d24d8/proton-c/bindings/cpp/src/include/event_loop_impl.hpp
----------------------------------------------------------------------
diff --git a/proton-c/bindings/cpp/src/include/event_loop_impl.hpp b/proton-c/bindings/cpp/src/include/event_loop_impl.hpp
new file mode 100644
index 0000000..b34a981
--- /dev/null
+++ b/proton-c/bindings/cpp/src/include/event_loop_impl.hpp
@@ -0,0 +1,39 @@
+#ifndef PROTON_CPP_EVENT_LOOP_IMPL_HPP
+#define PROTON_CPP_EVENT_LOOP_IMPL_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.
+ *
+ */
+
+#include "proton/fwd.hpp"
+
+namespace proton {
+
+class event_loop::impl {
+  public:
+    bool inject(void_function0& f);
+#if PN_CPP_HAS_CPP11
+    bool inject(std::function<void()> f);
+#endif
+};
+
+}
+
+#endif // PROTON_CPP_EVENT_LOOP_IMPL_HPP

http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/f89d24d8/proton-c/bindings/cpp/src/io/connection_driver.cpp
----------------------------------------------------------------------
diff --git a/proton-c/bindings/cpp/src/io/connection_driver.cpp b/proton-c/bindings/cpp/src/io/connection_driver.cpp
index ca9f68e..148a00b 100644
--- a/proton-c/bindings/cpp/src/io/connection_driver.cpp
+++ b/proton-c/bindings/cpp/src/io/connection_driver.cpp
@@ -49,13 +49,21 @@ void connection_driver::init() {
 
 connection_driver::connection_driver() : handler_(0), container_(0) { init(); }
 
-connection_driver::connection_driver(class container& cont, event_loop* loop) : handler_(0),
container_(&cont) {
+connection_driver::connection_driver(class container& cont) : handler_(0), container_(&cont)
{
     init();
     connection_context& ctx = connection_context::get(connection());
     ctx.container = container_;
-    ctx.event_loop.reset(loop);
 }
 
+#if PN_CPP_HAS_RVALUE_REFERENCES
+connection_driver::connection_driver(class container& cont, event_loop&& loop)
: handler_(0), container_(&cont) {
+    init();
+    connection_context& ctx = connection_context::get(connection());
+    ctx.container = container_;
+    ctx.event_loop_ = loop.impl_.get();
+}
+#endif
+
 connection_driver::~connection_driver() {
     pn_connection_driver_destroy(&driver_);
 }

http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/f89d24d8/proton-c/bindings/cpp/src/thread_safe_test.cpp
----------------------------------------------------------------------
diff --git a/proton-c/bindings/cpp/src/thread_safe_test.cpp b/proton-c/bindings/cpp/src/thread_safe_test.cpp
index 5b5d487..3a72f7f 100644
--- a/proton-c/bindings/cpp/src/thread_safe_test.cpp
+++ b/proton-c/bindings/cpp/src/thread_safe_test.cpp
@@ -50,7 +50,7 @@ void test_new() {
     ASSERT_EQUAL(1, pn_refcount(c)); // Engine gone, thread_safe keeping c alive.
     delete p;
 
-#if PN_CPP_HAS_CPP11
+#if PN_CPP_HAS_SHARED_PTR
     {
         std::shared_ptr<thread_safe<connection> > sp;
         {
@@ -60,6 +60,8 @@ void test_new() {
         }
         ASSERT_EQUAL(1, pn_refcount(c)); // Engine gone, sp keeping c alive.
     }
+#endif
+#if PN_CPP_HAS_UNIQUE_PTR
     {
         std::unique_ptr<thread_safe<connection> > up;
         {


---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@qpid.apache.org
For additional commands, e-mail: commits-help@qpid.apache.org


Mime
View raw message