removed pointless extra arguments from dispatcher (close #190)

src/entt/signal/dispatcher.hpp

@@ -22,16 +22,12 @@ namespace entt {
  * events to be published all together once per tick.<br/>
  * Listeners are provided in the form of member functions. For each event of
  * type `Event`, listeners are such that they can be invoked with an argument of
- * type `const Event &` plus an extra list of arguments to forward with the
- * event itself, no matter what the return type is.
+ * type `const Event &`, no matter what the return type is.
  *
  * The type of the instances is `Class *` (a naked pointer). It means that users
  * must guarantee that the lifetimes of the instances overcome the one of the
  * dispatcher itself to avoid crashes.
- *
- * @tparam Args Types of arguments to forward along with an event.
  */
-template<typename... Args>
 class dispatcher {
     using event_family = family<struct internal_dispatcher_event_family>;
 
@@ -40,34 +36,35 @@ class dispatcher {
 
     struct base_wrapper {
         virtual ~base_wrapper() = default;
-        virtual void publish(Args...) = 0;
+        virtual void publish() = 0;
     };
 
     template<typename Event>
     struct signal_wrapper: base_wrapper {
-        using signal_type = sigh<void(const Event &, Args...)>;
+        using signal_type = sigh<void(const Event &)>;
         using sink_type = typename signal_type::sink_type;
 
-        void publish(Args... args) override {
+        void publish() override {
             for(const auto &event: events[current]) {
-                signal.publish(event, args...);
+                signal.publish(event);
             }
 
-            events[current].clear();
-            current = (current + 1) % std::extent<decltype(events)>::value;
+            events[current++].clear();
+            current %= std::extent<decltype(events)>::value;
         }
 
         inline sink_type sink() ENTT_NOEXCEPT {
             return signal.sink();
         }
 
-        inline void trigger(const Event &event, Args... args) {
-            signal.publish(event, args...);
+        template<typename... Args>
+        inline void trigger(Args &&... args) {
+            signal.publish({ std::forward<Args>(args)... });
         }
 
-        template<typename... Params>
-        inline void enqueue(Params &&... params) {
-            events[current].emplace_back(std::forward<Params>(params)...);
+        template<typename... Args>
+        inline void enqueue(Args &&... args) {
+            events[current].emplace_back(std::forward<Args>(args)...);
         }
 
     private:
@@ -157,12 +154,12 @@ public:
      * The event is discarded after the execution.
      *
      * @tparam Event Type of event to trigger.
-     * @param event An instance of the given type of event.
-     * @param args Arguments to forward along with the event.
+     * @tparam Args Types of arguments to use to construct the event.
+     * @param args Arguments to use to construct the event.
      */
-    template<typename Event>
-    inline void trigger(Event &&event, Args... args) {
-        assure<std::decay_t<Event>>().trigger(std::forward<Event>(event), args...);
+    template<typename Event, typename... Args>
+    inline void trigger(Args &&... args) {
+        assure<Event>().trigger(std::forward<Args>(args)...);
     }
 
     /**
@@ -172,11 +169,11 @@ public:
      * The event is discarded after the execution.
      *
      * @tparam Event Type of event to trigger.
-     * @param args Arguments to forward along with the event.
+     * @param event An instance of the given type of event.
      */
     template<typename Event>
-    inline void trigger(Args... args) {
-        assure<std::decay_t<Event>>().trigger(Event{}, args...);
+    inline void trigger(Event &&event) {
+        assure<std::decay_t<Event>>().trigger(std::forward<Event>(event));
     }
 
     /**
@@ -186,12 +183,12 @@ public:
      * `update` member function to notify listeners when ready.
      *
      * @tparam Event Type of event to enqueue.
-     * @tparam Params Types of arguments to use to construct the event.
-     * @param params Arguments to use to construct the event.
+     * @tparam Args Types of arguments to use to construct the event.
+     * @param args Arguments to use to construct the event.
      */
-    template<typename Event, typename... Params>
-    inline void enqueue(Params &&... params) {
-        assure<Event>().enqueue(std::forward<Params>(params)...);
+    template<typename Event, typename... Args>
+    inline void enqueue(Args &&... args) {
+        assure<Event>().enqueue(std::forward<Args>(args)...);
     }
 
     /**
@@ -216,11 +213,10 @@ public:
      * to reduce at a minimum the time spent in the bodies of the listeners.
      *
      * @tparam Event Type of events to send.
-     * @param args Arguments to forward along with the event.
      */
     template<typename Event>
-    inline void update(Args... args) {
-        assure<Event>().publish(args...);
+    inline void update() {
+        assure<Event>().publish();
     }
 
     /**
@@ -229,15 +225,13 @@ public:
      * This method is blocking and it doesn't return until all the events are
      * delivered to the registered listeners. It's responsibility of the users
      * to reduce at a minimum the time spent in the bodies of the listeners.
-     *
-     * @param args Arguments to forward along with the event.
      */
-    inline void update(Args... args) const {
+    inline void update() const {
         for(auto pos = wrappers.size(); pos; --pos) {
             auto &wdata = wrappers[pos-1];
 
             if(wdata.wrapper) {
-                wdata.wrapper->publish(args...);
+                wdata.wrapper->publish();
             }
         }
     }

test/entt/signal/dispatcher.cpp

@@ -10,43 +10,44 @@ struct one_more_event {};
 ENTT_SHARED_TYPE(an_event)
 
 struct receiver {
-    void receive(const an_event &, int value) { cnt += value; }
+    void receive(const an_event &) { ++cnt; }
     void reset() { cnt = 0; }
     int cnt{0};
 };
 
 TEST(Dispatcher, Functionalities) {
-    entt::dispatcher<int> dispatcher;
+    entt::dispatcher dispatcher;
     receiver receiver;
 
-    dispatcher.trigger<one_more_event>(1);
+    dispatcher.trigger<one_more_event>();
     dispatcher.enqueue<one_more_event>();
-    dispatcher.update<one_more_event>(1);
+    dispatcher.update<one_more_event>();
 
     dispatcher.sink<an_event>().connect<&receiver::receive>(&receiver);
-    dispatcher.trigger<an_event>(1);
+    dispatcher.trigger<an_event>();
     dispatcher.enqueue<an_event>();
 
+    ASSERT_EQ(receiver.cnt, 1);
+
     dispatcher.enqueue<another_event>();
-    dispatcher.update<another_event>(1);
+    dispatcher.update<another_event>();
 
     ASSERT_EQ(receiver.cnt, 1);
 
-    dispatcher.update<an_event>(2);
-    dispatcher.trigger<an_event>(1);
+    dispatcher.update<an_event>();
+    dispatcher.trigger<an_event>();
 
-    ASSERT_EQ(receiver.cnt, 4);
+    ASSERT_EQ(receiver.cnt, 3);
 
     receiver.reset();
 
     an_event event{};
-    const an_event &cevent = event;
 
     dispatcher.sink<an_event>().disconnect<&receiver::receive>(&receiver);
-    dispatcher.trigger(an_event{}, 1);
+    dispatcher.trigger<an_event>();
     dispatcher.enqueue(event);
-    dispatcher.update(1);
-    dispatcher.trigger(cevent, 1);
+    dispatcher.update();
+    dispatcher.trigger(std::as_const(event));
 
     ASSERT_EQ(receiver.cnt, 0);
 }

test/lib/a_module.cpp

@@ -43,7 +43,7 @@ LIB_EXPORT void update_position(int delta, entt::registry<> &registry) {
     });
 }
 
-LIB_EXPORT void trigger_another_event(entt::dispatcher<> &dispatcher) {
+LIB_EXPORT void trigger_another_event(entt::dispatcher &dispatcher) {
     dispatcher.trigger<another_event>();
 }
 

test/lib/another_module.cpp

@@ -48,8 +48,8 @@ LIB_EXPORT void assign_velocity(int vel, entt::registry<> &registry) {
     }
 }
 
-LIB_EXPORT void trigger_an_event(int payload, entt::dispatcher<> &dispatcher) {
-    dispatcher.trigger(an_event{payload});
+LIB_EXPORT void trigger_an_event(int payload, entt::dispatcher &dispatcher) {
+    dispatcher.trigger<an_event>(payload);
 }
 
 LIB_EXPORT void emit_an_event(int payload, test_emitter &emitter) {

test/lib/lib.cpp

@@ -12,8 +12,8 @@ extern typename entt::registry<>::component_type another_module_char_type();
 extern void update_position(int delta, entt::registry<> &);
 extern void assign_velocity(int, entt::registry<> &);
 
-extern void trigger_an_event(int, entt::dispatcher<> &);
-extern void trigger_another_event(entt::dispatcher<> &);
+extern void trigger_an_event(int, entt::dispatcher &);
+extern void trigger_another_event(entt::dispatcher &);
 
 struct listener {
     void on_an_event(an_event event) { value = event.payload; }
@@ -64,7 +64,7 @@ TEST(Lib, Registry) {
 }
 
 TEST(Lib, Dispatcher) {
-    entt::dispatcher<> dispatcher;
+    entt::dispatcher dispatcher;
     listener listener;
 
     dispatcher.sink<an_event>().connect<&listener::on_an_event>(&listener);