1 #ifndef PROTON_THREAD_SAFE_HPP 2 #define PROTON_THREAD_SAFE_HPP 26 #include "./internal/config.hpp" 27 #include "./connection.hpp" 28 #include "./event_loop.hpp" 29 #include "./function.hpp" 30 #include "./internal/object.hpp" 31 #include "./internal/type_traits.hpp" 38 template <
class T>
struct endpoint_traits;
39 template<>
struct endpoint_traits<connection> {};
40 template<>
struct endpoint_traits<session> {};
41 template<>
struct endpoint_traits<link> {};
42 template<>
struct endpoint_traits<sender> {};
43 template<>
struct endpoint_traits<receiver> {};
63 class thread_safe :
private internal::pn_ptr_base,
private internal::endpoint_traits<T> {
64 typedef typename T::pn_type pn_type;
66 struct inject_decref :
public void_function0 {
68 inject_decref(pn_type* p) : ptr_(p) {}
69 void operator()() PN_CPP_OVERRIDE { decref(ptr_);
delete this; }
74 static void operator delete(
void*) {}
80 #if PN_CPP_HAS_STD_BIND 81 event_loop().inject(std::bind(&decref, ptr()));
83 event_loop().inject(*
new inject_decref(ptr()));
99 static void*
operator new(size_t, pn_type* p) {
return p; }
100 static void operator delete(
void*, pn_type*) {}
102 pn_type* ptr() {
return reinterpret_cast<pn_type*
>(
this); }
110 friend class returned<T>;
119 class returned :
private internal::endpoint_traits<T>
128 returned(
const returned& x) : ptr_(const_cast<returned&>(x).release()) {}
130 ~returned() {
if (ptr_)
delete ptr_; }
139 operator T() {
return ptr_->
unsafe(); }
141 #if PN_CPP_HAS_SHARED_PTR 142 operator std::shared_ptr<thread_safe<T> >() {
144 return std::shared_ptr<thread_safe<T> >(release());
147 #if PN_CPP_HAS_UNIQUE_PTR 148 operator std::unique_ptr<thread_safe<T> >() {
150 return std::unique_ptr<thread_safe<T> >(release());
155 void operator=(
const returned&);
162 #if PN_CPP_HAS_SHARED_PTR 168 #if PN_CPP_HAS_UNIQUE_PTR 178 #endif // PROTON_THREAD_SAFE_HPP class event_loop & event_loop()
Get the event loop for this object.
Definition: thread_safe.hpp:92
Experimental - A serial execution context.
Definition: event_loop.hpp:44
T unsafe()
Get the thread-unsafe proton object wrapped by this thread_safe<T>
Definition: thread_safe.hpp:95
std::shared_ptr< thread_safe< T > > make_shared_thread_safe(const T &obj)
Create a thread-safe shared_ptr to obj.
Definition: thread_safe.hpp:164
std::unique_ptr< thread_safe< T > > make_unique_thread_safe(const T &obj)
Create a thread-safe unique_ptr to obj.
Definition: thread_safe.hpp:170
returned< T > make_thread_safe(const T &obj)
Make a thread-safe wrapper for obj.
Definition: thread_safe.hpp:160
The main Proton namespace.
Definition: annotation_key.hpp:30
Experimental - A thread-safe object wrapper.
Definition: fwd.hpp:65