Repository: qpid-proton Updated Branches: refs/heads/master 7bc06c96d -> 6243919fd
PROTON-1232: [C++ binding] Improve default_container construction Project: http://git-wip-us.apache.org/repos/asf/qpid-proton/repo Commit: http://git-wip-us.apache.org/repos/asf/qpid-proton/commit/6243919f Tree: http://git-wip-us.apache.org/repos/asf/qpid-proton/tree/6243919f Diff: http://git-wip-us.apache.org/repos/asf/qpid-proton/diff/6243919f Branch: refs/heads/master Commit: 6243919fd47e36afaab16bb9183af244fd8b0338 Parents: 7bc06c9 Author: Andrew Stitcher <[email protected]> Authored: Fri May 27 17:10:06 2016 -0400 Committer: Andrew Stitcher <[email protected]> Committed: Fri Jun 10 14:35:36 2016 -0400 ---------------------------------------------------------------------- .../bindings/cpp/include/proton/container.hpp | 83 ++++++++++++--- .../cpp/include/proton/default_container.hpp | 106 +++++++------------ .../cpp/include/proton/internal/config.hpp | 8 +- .../include/proton/internal/pn_unique_ptr.hpp | 2 +- proton-c/bindings/cpp/src/container_impl.cpp | 45 ++++---- 5 files changed, 137 insertions(+), 107 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/6243919f/proton-c/bindings/cpp/include/proton/container.hpp ---------------------------------------------------------------------- diff --git a/proton-c/bindings/cpp/include/proton/container.hpp b/proton-c/bindings/cpp/include/proton/container.hpp index 9665346..ed48803 100644 --- a/proton-c/bindings/cpp/include/proton/container.hpp +++ b/proton-c/bindings/cpp/include/proton/container.hpp @@ -23,11 +23,12 @@ */ #include "./connection_options.hpp" -#include "./error_condition.hpp" #include "./listener.hpp" -#include "./internal/pn_unique_ptr.hpp" #include "./thread_safe.hpp" +#include "./internal/config.hpp" +#include "./internal/export.hpp" + #include <string> namespace proton { @@ -37,14 +38,13 @@ class connection_options; class container_impl; class messaging_handler; class listen_handler; +class listener; class receiver; class receiver_options; class sender; class sender_options; class task; -class container; - /// A top-level container of connections, sessions, senders, and /// receivers. /// @@ -94,11 +94,11 @@ class PN_CPP_CLASS_EXTERN container { /// Listen with a fixed set of options for all accepted connections. /// See listen(const std::string&, listen_handler&) - PN_CPP_EXTERN virtual listener listen(const std::string& url, const connection_options&); + PN_CPP_EXTERN listener listen(const std::string& url, const connection_options&); /// Start listening on URL. /// New connections will use the handler from server_connection_options() - PN_CPP_EXTERN virtual listener listen(const std::string& url); + PN_CPP_EXTERN listener listen(const std::string& url); /// Run the container in this thread. /// Returns when the container stops. @@ -123,17 +123,17 @@ class PN_CPP_CLASS_EXTERN container { /// Stop the container with an empty error condition. /// @see stop(const error_condition&) - PN_CPP_EXTERN virtual void stop(); + PN_CPP_EXTERN void stop(); /// Open a connection and sender for `url`. - PN_CPP_EXTERN virtual returned<sender> open_sender(const std::string &url); + PN_CPP_EXTERN returned<sender> open_sender(const std::string &url); /// Open a connection and sender for `url`. /// /// Any supplied sender options will override the container's /// template options. - PN_CPP_EXTERN virtual returned<sender> open_sender(const std::string &url, - const proton::sender_options &o); + PN_CPP_EXTERN returned<sender> open_sender(const std::string &url, + const proton::sender_options &o); /// Open a connection and sender for `url`. /// @@ -144,15 +144,15 @@ class PN_CPP_CLASS_EXTERN container { const connection_options &c) = 0; /// Open a connection and receiver for `url`. - PN_CPP_EXTERN virtual returned<receiver> open_receiver(const std::string&url); + PN_CPP_EXTERN returned<receiver> open_receiver(const std::string&url); /// Open a connection and receiver for `url`. /// /// Any supplied receiver options will override the container's /// template options. - PN_CPP_EXTERN virtual returned<receiver> open_receiver(const std::string&url, - const proton::receiver_options &o); + PN_CPP_EXTERN returned<receiver> open_receiver(const std::string&url, + const proton::receiver_options &o); /// Open a connection and receiver for `url`. /// @@ -200,6 +200,63 @@ class PN_CPP_CLASS_EXTERN container { }; +/// This is an header only class that can be used to help using containers more natural +/// by allowing them to be treated as value types. +template <class Ptr> +class container_ref : public container { + public: +#if PN_CPP_HAS_RVALUE_REFERENCES + container_ref(Ptr&& p) : impl_(std::move(p)) {} +#else + // This class will only work correctly if ownership is transferred here + // so using std::auto_ptr for Ptr is necessary for pre C++11 + container_ref(Ptr p) : impl_(p) {} +#endif + + // Pull in base class functions here so we don't need to define them again + using container::stop; + using container::connect; + using container::listen; + using container::open_receiver; + using container::open_sender; + + returned<connection> connect(const std::string& url, const connection_options& opts) { return impl_->connect(url, opts); } + listener listen(const std::string& url, listen_handler& l) { return impl_->listen(url, l); } + + void stop_listening(const std::string& url) { impl_->stop_listening(url); } + void run() { impl_->run(); } + void auto_stop(bool set) { impl_->auto_stop(set); } + + void stop(const error_condition& err) { impl_->stop(err); } + + returned<sender> open_sender( + const std::string &url, + const class sender_options &o, + const connection_options &c) { return impl_->open_sender(url, o, c); } + + returned<receiver> open_receiver( + const std::string&url, + const class receiver_options &o, + const connection_options &c) { return impl_->open_receiver(url, o, c); } + + std::string id() const { return impl_->id(); } + + void client_connection_options(const connection_options& c) { impl_->client_connection_options(c); } + connection_options client_connection_options() const { return impl_->client_connection_options(); } + + void server_connection_options(const connection_options &o) { impl_->server_connection_options(o); } + connection_options server_connection_options() const { return impl_->server_connection_options(); } + + void sender_options(const class sender_options &o) { impl_->sender_options(o); } + class sender_options sender_options() const { return impl_->sender_options(); } + + void receiver_options(const class receiver_options & o) { impl_->receiver_options(o); } + class receiver_options receiver_options() const { return impl_->receiver_options(); } + + private: + Ptr impl_; +}; + } // proton #endif // PROTON_CONTAINER_HPP http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/6243919f/proton-c/bindings/cpp/include/proton/default_container.hpp ---------------------------------------------------------------------- diff --git a/proton-c/bindings/cpp/include/proton/default_container.hpp b/proton-c/bindings/cpp/include/proton/default_container.hpp index f50869c..9934be7 100644 --- a/proton-c/bindings/cpp/include/proton/default_container.hpp +++ b/proton-c/bindings/cpp/include/proton/default_container.hpp @@ -24,77 +24,47 @@ #include "./container.hpp" -namespace proton { - -/// A single-threaded container. -/// -/// @copydoc container -class PN_CPP_CLASS_EXTERN default_container : public container { - public: - /// Create a default, single-threaded container with a messaging_handler. - /// The messaging_handler will be called for all events on all connections in the container. - /// - /// Container ID should be unique within your system. If empty a random UUID is generated. - PN_CPP_EXTERN explicit default_container(proton::messaging_handler& h, const std::string& id = ""); - - /// Create a default, single-threaded container without a messaging_handler. - /// - /// Connections get their handlesr via proton::connection_options. - /// Container-wide defaults are set with client_connection_options() and - /// server_connection_options(). Per-connection options are set in connect() - /// and proton_listen_handler::on_accept for the proton::listen_handler - /// passed to listen() - /// - /// Container ID should be unique within your system. If empty a random UUID is generated. - PN_CPP_EXTERN explicit default_container(const std::string& id = ""); - - /// Wrap an existing container implementation as a default_container. - /// Takes ownership of c. - PN_CPP_EXTERN explicit default_container(container* c) : impl_(c) {} - - PN_CPP_EXTERN returned<connection> connect(const std::string& url, const connection_options &) PN_CPP_OVERRIDE; - PN_CPP_EXTERN listener listen(const std::string& url, listen_handler& l) PN_CPP_OVERRIDE; - using container::listen; - - /// @cond INTERNAL - /// XXX Make private - PN_CPP_EXTERN void stop_listening(const std::string& url) PN_CPP_OVERRIDE; - /// @endcond - - PN_CPP_EXTERN void run() PN_CPP_OVERRIDE; - PN_CPP_EXTERN void auto_stop(bool set) PN_CPP_OVERRIDE; - - PN_CPP_EXTERN void stop(const error_condition& err) PN_CPP_OVERRIDE; - - PN_CPP_EXTERN returned<sender> open_sender( - const std::string &url, - const proton::sender_options &o, - const connection_options &c) PN_CPP_OVERRIDE; - using container::open_sender; +#include "./internal/config.hpp" +#include "./internal/export.hpp" - PN_CPP_EXTERN returned<receiver> open_receiver( - const std::string&url, - const proton::receiver_options &o, - const connection_options &c) PN_CPP_OVERRIDE; - using container::open_receiver; +#include <memory> +#include <string> - PN_CPP_EXTERN std::string id() const PN_CPP_OVERRIDE; - - PN_CPP_EXTERN void client_connection_options(const connection_options &o) PN_CPP_OVERRIDE; - PN_CPP_EXTERN connection_options client_connection_options() const PN_CPP_OVERRIDE; - - PN_CPP_EXTERN void server_connection_options(const connection_options &o) PN_CPP_OVERRIDE; - PN_CPP_EXTERN connection_options server_connection_options() const PN_CPP_OVERRIDE; - - PN_CPP_EXTERN void sender_options(const class sender_options &o) PN_CPP_OVERRIDE; - PN_CPP_EXTERN class sender_options sender_options() const PN_CPP_OVERRIDE; - - PN_CPP_EXTERN void receiver_options(const class receiver_options & o) PN_CPP_OVERRIDE; - PN_CPP_EXTERN class receiver_options receiver_options() const PN_CPP_OVERRIDE; - - private: - internal::pn_unique_ptr<container> impl_; +namespace proton { +class messaging_handler; + +// Avoid deprecated diagnostics from auto_ptr +#if defined(__GNUC__) || defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +#endif +/// Default container factory for C++03, not recommended unless you only have C++03 +PN_CPP_EXTERN std::auto_ptr<container> make_auto_default_container(messaging_handler&, const std::string& id=""); +PN_CPP_EXTERN std::auto_ptr<container> make_auto_default_container(const std::string& id=""); + +#if PN_CPP_HAS_UNIQUE_PTR +/// Default container factory +PN_CPP_EXTERN std::unique_ptr<container> make_default_container(messaging_handler&, const std::string& id=""); +PN_CPP_EXTERN std::unique_ptr<container> make_default_container(const std::string& id=""); +#endif + +#if PN_CPP_HAS_UNIQUE_PTR +class default_container : public container_ref<std::unique_ptr<container> > { +public: + default_container(messaging_handler& h, const std::string& id="") : container_ref(make_default_container(h, id)) {} + default_container(const std::string& id="") : container_ref(make_default_container(id)) {} }; +#else +class default_container : public container_ref<std::auto_ptr<container> > { +public: + default_container(messaging_handler& h, const std::string& id="") : container_ref(make_auto_default_container(h, id)) {} + default_container(const std::string& id="") : container_ref(make_auto_default_container(id)) {} +}; +#endif + +#if defined(__GNUC__) || defined(__clang__) +#pragma GCC diagnostic pop +#endif } // proton http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/6243919f/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 ce45118..ff7af09 100644 --- a/proton-c/bindings/cpp/include/proton/internal/config.hpp +++ b/proton-c/bindings/cpp/include/proton/internal/config.hpp @@ -41,8 +41,12 @@ #endif #endif -#ifndef PN_CPP_HAS_STD_PTR -#define PN_CPP_HAS_STD_PTR PN_CPP_HAS_CPP11 +#ifndef PN_CPP_HAS_SHARED_PTR +#define PN_CPP_HAS_SHARED_PTR PN_CPP_HAS_CPP11 +#endif + +#ifndef PN_CPP_HAS_UNIQUE_PTR +#define PN_CPP_HAS_UNIQUE_PTR PN_CPP_HAS_CPP11 #endif #ifndef PN_CPP_HAS_LONG_LONG http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/6243919f/proton-c/bindings/cpp/include/proton/internal/pn_unique_ptr.hpp ---------------------------------------------------------------------- diff --git a/proton-c/bindings/cpp/include/proton/internal/pn_unique_ptr.hpp b/proton-c/bindings/cpp/include/proton/internal/pn_unique_ptr.hpp index cc29ba0..323c701 100644 --- a/proton-c/bindings/cpp/include/proton/internal/pn_unique_ptr.hpp +++ b/proton-c/bindings/cpp/include/proton/internal/pn_unique_ptr.hpp @@ -56,7 +56,7 @@ template <class T> class pn_unique_ptr { #endif bool operator !() const { return !get(); } -#if PN_CPP_HAS_STD_PTR +#if PN_CPP_HAS_UNIQUE_PTR operator std::unique_ptr<T>() { T *p = ptr_; ptr_ = 0; return std::unique_ptr<T>(p); } #endif http://git-wip-us.apache.org/repos/asf/qpid-proton/blob/6243919f/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 ce6a2b2..3f7ad45 100644 --- a/proton-c/bindings/cpp/src/container_impl.cpp +++ b/proton-c/bindings/cpp/src/container_impl.cpp @@ -276,30 +276,29 @@ void container_impl::auto_stop(bool set) { auto_stop_ = set; } +#if PN_CPP_HAS_UNIQUE_PTR +std::unique_ptr<container> make_default_container(messaging_handler& h, const std::string& id) { + return std::unique_ptr<container>(new container_impl(id, &h)); +} +std::unique_ptr<container> make_default_container(const std::string& id) { + return std::unique_ptr<container>(new container_impl(id)); +} +#endif -default_container::default_container(messaging_handler& h, const std::string& id) : impl_(new container_impl(id, &h)) {} -default_container::default_container(const std::string& id) : impl_(new container_impl(id)) {} - -returned<connection> default_container::connect(const std::string& url, const connection_options &o) { return impl_->connect(url, o); } -listener default_container::listen(const std::string& url, listen_handler& l) { return impl_->listen(url, l); } -void default_container::stop_listening(const std::string& url) { impl_->stop_listening(url); } - -void default_container::run() { impl_->run(); } -void default_container::auto_stop(bool set) { impl_->auto_stop(set); } -void default_container::stop(const error_condition& err) { impl_->stop(err); } - -returned<sender> default_container::open_sender(const std::string &u, const proton::sender_options &o, const connection_options &c) { return impl_->open_sender(u, o, c); } -returned<receiver> default_container::open_receiver(const std::string &u, const proton::receiver_options &o, const connection_options &c) { return impl_->open_receiver(u, o, c); } - -std::string default_container::id() const { return impl_->id(); } -void default_container::client_connection_options(const connection_options &o) { impl_->client_connection_options(o); } -connection_options default_container::client_connection_options() const { return impl_->client_connection_options(); } -void default_container::server_connection_options(const connection_options &o) { impl_->server_connection_options(o); } -connection_options default_container::server_connection_options() const { return impl_->server_connection_options(); } -void default_container::sender_options(const class sender_options &o) { impl_->sender_options(o); } -class sender_options default_container::sender_options() const { return impl_->sender_options(); } -void default_container::receiver_options(const class receiver_options & o) { impl_->receiver_options(o); } -class receiver_options default_container::receiver_options() const { return impl_->receiver_options(); } +// Avoid deprecated diagnostics from auto_ptr +#if defined(__GNUC__) || defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +#endif +std::auto_ptr<container> make_auto_default_container(messaging_handler& h, const std::string& id) { + return std::auto_ptr<container>(new container_impl(id, &h)); +} +std::auto_ptr<container> make_auto_default_container(const std::string& id) { + return std::auto_ptr<container>(new container_impl(id)); +} +#if defined(__GNUC__) || defined(__clang__) +#pragma GCC diagnostic pop +#endif } --------------------------------------------------------------------- To unsubscribe, e-mail: [email protected] For additional commands, e-mail: [email protected]
