channel.hpp

Go to the documentation of this file.

#pragma once
 
//clashes with BOOST PP and Some Applications
#pragma push_macro("N")
#undef N
 
#include <boost/asio.hpp>
#include <boost/signals2.hpp>
#include <boost/exception/diagnostic_information.hpp>
 
namespace appbase {
 
   using erased_channel_ptr = std::unique_ptr<void, void(*)(void*)>;
 
   struct drop_exceptions {
      drop_exceptions() = default;
      using result_type = void;
 
      template<typename InputIterator>
      result_type operator()(InputIterator first, InputIterator last) {
         while (first != last) {
            try {
               *first;
            } catch (...) {
               // drop
            }
            ++first;
         }
      }
   };
 
   template<typename Data, typename DispatchPolicy>
   class channel final {
      public:
         class handle {
            public:
               ~handle() {
                  unsubscribe();
               }
 
               void unsubscribe() {
                  if (_handle.connected()) {
                     _handle.disconnect();
                  }
               }
 
               // This handle can be constructed and moved
               handle() = default;
               handle(handle&&) = default;
               handle& operator= (handle&& rhs) = default;
 
               // dont allow copying since this protects the resource
               handle(const handle& ) = delete;
               handle& operator= (const handle& ) = delete;
 
            private:
               using handle_type = boost::signals2::connection;
               handle_type _handle;
 
               handle(handle_type&& _handle)
               :_handle(std::move(_handle))
               {}
 
               friend class channel;
         };
 
         void publish(int priority, const Data& data);
 
         template<typename Callback>
         handle subscribe(Callback cb) {
            return handle(_signal.connect(cb));
         }
 
         auto set_dispatcher(const DispatchPolicy& policy ) -> std::enable_if_t<std::is_copy_constructible<DispatchPolicy>::value,void>
         {
            _signal.set_combiner(policy);
         }
 
         bool has_subscribers() {
            auto connections = _signal.num_slots();
            return connections > 0;
         }
 
      private:
         channel()
         {
         }
 
         virtual ~channel() = default;
 
         static void deleter(void* erased_channel_ptr) {
            auto ptr = reinterpret_cast<channel*>(erased_channel_ptr);
            delete ptr;
         }
 
         static channel* get_channel(erased_channel_ptr& ptr) {
            return reinterpret_cast<channel*>(ptr.get());
         }
 
         static erased_channel_ptr make_unique()
         {
            return erased_channel_ptr(new channel(), &deleter);
         }
 
         boost::signals2::signal<void(const Data&), DispatchPolicy> _signal;
 
         friend class appbase::application;
   };
 
   template< typename Tag, typename Data, typename DispatchPolicy = drop_exceptions >
   struct channel_decl {
      using channel_type = channel<Data, DispatchPolicy>;
      using tag_type = Tag;
   };
 
   template <typename...Ts>
   std::true_type is_channel_decl_impl(const channel_decl<Ts...>*);
 
   std::false_type is_channel_decl_impl(...);
 
   template <typename T>
   using is_channel_decl = decltype(is_channel_decl_impl(std::declval<T*>()));
}
 
#pragma pop_macro("N")