method.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/signals2.hpp>
#include <boost/exception/diagnostic_information.hpp>
 
namespace appbase {
 
   using erased_method_ptr = std::unique_ptr<void, void(*)(void*)>;
 
   template<typename FunctionSig>
   struct first_success_policy;
 
   template<typename Ret, typename ... Args>
   struct first_success_policy<Ret(Args...)> {
      using result_type = Ret;
 
      template<typename InputIterator>
      Ret operator()(InputIterator first, InputIterator last) {
         std::string err;
         while (first != last) {
            try {
               return *first; // de-referencing the iterator causes the provider to run
            } catch (...) {
               if (!err.empty()) {
                  err += "\",\"";
               }
 
               err += boost::current_exception_diagnostic_information();
            }
 
            ++first;
         }
 
         throw std::length_error(std::string("No Result Available, All providers returned exceptions[") + err + "]");
      }
   };
 
   template<typename ... Args>
   struct first_success_policy<void(Args...)> {
      using result_type = void;
 
      template<typename InputIterator>
      void operator()(InputIterator first, InputIterator last) {
         std::string err;
 
         while (first != last) {
            try {
               *first; // de-referencing the iterator causes the provider to run
            } catch (...) {
               if (!err.empty()) {
                  err += "\",\"";
               }
 
               err += boost::current_exception_diagnostic_information();
            }
 
            ++first;
         }
 
         throw std::length_error(std::string("No Result Available, All providers returned exceptions[") + err + "]");
      }
   };
 
 
   template<typename FunctionSig>
   struct first_provider_policy;
 
   template<typename Ret, typename ... Args>
   struct first_provider_policy<Ret(Args...)> {
      using result_type = Ret;
 
      template<typename InputIterator>
      Ret operator()(InputIterator first, InputIterator) {
         return *first;
      }
   };
 
   template<typename ... Args>
   struct first_provider_policy<void(Args...)> {
      using result_type = void;
 
      template<typename InputIterator>
      void operator()(InputIterator first, InputIterator) {
         *first;
      }
   };
 
   namespace impl {
      template<typename FunctionSig, typename DispatchPolicy>
      class method_caller;
 
      template<typename Ret, typename ...Args, typename DispatchPolicy>
      class method_caller<Ret(Args...), DispatchPolicy> {
         public:
            using signal_type = boost::signals2::signal<Ret(Args...), DispatchPolicy>;
            using result_type = Ret;
 
            method_caller()
            {}
 
            Ret operator()(Args&&... args)
            {
               return _signal(std::forward<Args>(args)...);
            }
 
            signal_type _signal;
      };
 
      template<typename ...Args, typename DispatchPolicy>
      class method_caller<void(Args...), DispatchPolicy> {
         public:
            using signal_type = boost::signals2::signal<void(Args...), DispatchPolicy>;
            using result_type = void;
 
            method_caller()
            {}
 
            void operator()(Args&&... args)
            {
               _signal(std::forward<Args>(args)...);
            }
 
            signal_type _signal;
      };
   }
 
   template<typename FunctionSig, typename DispatchPolicy>
   class method final : public impl::method_caller<FunctionSig,DispatchPolicy> {
      public:
         class handle {
            public:
               ~handle() {
                  unregister();
               }
 
               void unregister() {
                  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 method;
         };
 
         template<typename T>
         handle register_provider(T provider, int priority = 0) {
            return handle(this->_signal.connect(priority, provider));
         }
 
      protected:
         method() = default;
         virtual ~method() = default;
 
         static void deleter(void* erased_method_ptr) {
            auto ptr = reinterpret_cast<method*>(erased_method_ptr);
            delete ptr;
         }
 
         static method* get_method(erased_method_ptr& ptr) {
            return reinterpret_cast<method*>(ptr.get());
         }
 
         static erased_method_ptr make_unique() {
            return erased_method_ptr(new method(), &deleter);
         }
 
         friend class appbase::application;
   };
 
 
   template< typename Tag, typename FunctionSig, template <typename> class DispatchPolicy = first_success_policy>
   struct method_decl {
      using method_type = method<FunctionSig, DispatchPolicy<FunctionSig>>;
      using tag_type = Tag;
   };
 
   template <typename Tag, typename FunctionSig, template <typename> class DispatchPolicy>
   std::true_type is_method_decl_impl(const method_decl<Tag, FunctionSig, DispatchPolicy>*);
 
   std::false_type is_method_decl_impl(...);
 
   template <typename T>
   using is_method_decl = decltype(is_method_decl_impl(std::declval<T*>()));
 
 
}
 
#pragma pop_macro("N")