Rename event to trigger

README.md

@@ -3,6 +3,12 @@
 
 A C++ library for event-driven asynchronous multi-threaded programming.
 
+## Motivation
+
+The original concept was to create an interface capable of asynchronously calling any function. It has since evolved into a library that incorporates a thread pool, each with its own event loop, event-driven programming, and functions inherently designed for asynchronous operation (including periodic and delayed functions).
+
+The asynchronous filesystem is provided solely to guide users on how to wrap any time- or IO-intensive function for asynchronous execution.
+
 ## Features
 
 - Object oriented
@@ -10,8 +16,8 @@ A C++ library for event-driven asynchronous multi-threaded programming.
 - Header only
 - Asynchronous programming
 - Multithread
-- Asynchronous timer functions: interval, timeout
-- Typed events (on, emit, off)
+- Asynchronous timer functions: periodic, delayed (like setInterval and setTimeout from JS)
+- Typed events (on, tick, off) (like EventEmitter from JS: on, emit, etc)
 - Event loops
 - Multiple parallel execution loops
 - Asynchronous file IO
@@ -23,14 +29,14 @@ Just download the latest release and unzip it into your project.
 ```c++
 #define NUM_OF_RUNNERS 8                // To change the number of threads used by atask, without this it runs according to the number of cores
 
-#include "asynco/lib/asynco.hpp"          // atask(), wait()
-#include "asynco/lib/event.hpp"          // event
-#include "asynco/lib/timers.hpp"          // interval, timeout
-#include "asynco/lib/filesystem.hpp"     // for async read and write files
+#include "asynco/lib/asynco.hpp"        // atask(), wait()
+#include "asynco/lib/triggers.hpp"      // trigger (event emitter)
+#include "asynco/lib/timers.hpp"        // periodic, delayed (like setInterval and setTimeout from JS)
+#include "asynco/lib/filesystem.hpp"    // for async read and write files
 
 using namespace marcelb;
 using namespace asynco;
-using namespace events;
+using namespace triggers;
 
 // At the end of the main function, always set
 _asynco_engine.run();
@@ -43,12 +49,12 @@ return 0;
 Time asynchronous functions
 
 ```c++
-// start interval
-interval inter1 ([]() {
+// start periodic
+periodic inter1 ([]() {
      cout << "Interval 1" << endl;
 }, 1000);
 
-// stop interval
+// stop periodic
 inter1.stop();
 
 // how many times it has expired
@@ -57,12 +63,12 @@ int t = inter1.ticks();
 // is it stopped
 bool stoped = inter1.stoped();
 
-// start timeout
-timeout time1 ( [] () {
+// start delayed
+delayed time1 ( [] () {
     cout << "Timeout 1 " << endl;
 }, 10000);
 
-// stop timeout
+// stop delayed
 time1.stop();
 
 // is it expired
@@ -137,12 +143,12 @@ cout << wait(atask( [] () {
 })) << endl;
 
 /**
-* Sleep with timeout sleep implement
+* Sleep with delayed sleep implement
 */
 
 void sleep_to (int _time) {
     promise<void> _promise;
-    timeout t( [&]() {
+    delayed t( [&]() {
         _promise.set_value();
     }, _time);
 
@@ -157,7 +163,7 @@ sleep_to(3000);
 
 void promise_reject (int _time) {
     promise<void> _promise;
-    timeout t( [&]() {
+    delayed t( [&]() {
         try {
             // simulate except
             throw runtime_error("Error simulation");
@@ -183,9 +189,9 @@ Events
 * initialization of typed events
 */
 
-event<int, int> ev2int;
-event<int, string> evintString;
-event<> evoid;
+trigger<int, int> ev2int;
+trigger<int, string> evintString;
+trigger<> evoid;
 
 ev2int.on("sum", [](int a, int b) {
     cout << "Sum " << a+b << endl;
@@ -213,32 +219,32 @@ sleep(1);
 * Emit
 */
 
-ev2int.emit("sum", 5, 8);
+ev2int.tick("sum", 5, 8);
 
 sleep(1);
-evintString.emit("substract", 3, to_string(2));
+evintString.tick("substract", 3, to_string(2));
 
 sleep(1);
-evoid.emit("void");
+evoid.tick("void");
 
 // Turn off the event listener
 
 evoid.off("void");
-evoid.emit("void"); // nothing is happening
+evoid.tick("void"); // nothing is happening
 
 ```
 Extend own class whit events
 
 ```c++
-class myOwnClass : public event<int> {
+class myOwnClass : public trigger<int> {
     public:
-    myOwnClass() : event() {};
+    myOwnClass() : trigger() {};
 };
 
 myOwnClass myclass;
 
-timeout t( [&] {
-    myclass.emit("constructed", 1);
+delayed t( [&] {
+    myclass.tick("constructed", 1);
 }, 200);
 
 myclass.on("constructed", [] (int i) {

lib/event.hpp

@@ -1,65 +0,0 @@
-#ifndef _EVENT_
-#define _EVENT_
-
-#include <map>
-#include <vector>
-#include <string>
-#include <functional>
-
-using namespace std;
-
-#include "asynco.hpp"
-namespace marcelb {
-namespace asynco {
-namespace events {
-
-/**
- * Event class, for event-driven programming.
- * These events are typed according to the arguments of the callback function
-*/
-template<typename... T>
-class event {
-    private:
-    mutex m_eve;
-    unordered_map<string, vector<function<void(T...)>>> events;
-
-    public:
-
-    /**
-     * Defines event by key, and callback function
-    */
-    void on(const string& key, function<void(T...)> callback) {
-        lock_guard _off(m_eve);
-        events[key].push_back(callback);
-    }
-
-    /**
-     * It emits an event and sends a callback function saved according to the key with the passed parameters
-    */
-    template<typename... Args>
-    void emit(const string& key, Args... args) {
-        auto it_eve = events.find(key);
-        if (it_eve != events.end()) {
-            for (uint i =0; i<it_eve->second.size(); i++) {
-                auto callback = bind(it_eve->second[i], forward<Args>(args)...); 
-                atask(callback);
-            }
-        }
-    }
-
-    /**
-     * Remove an event listener from an event
-    */
-    void off(const string& key) {
-        lock_guard _off(m_eve);
-        events.erase(key);
-    }
-
-
-};
-
-}
-}
-}
-
-#endif

lib/timers.hpp

@@ -1,5 +1,5 @@
-#ifndef _ROTOR_
-#define _ROTOT_
+#ifndef _TIMERS_
+#define _TIMERS_
 
 #include "asynco.hpp"
 #include <chrono>
@@ -113,22 +113,22 @@ class timer {
 };
 
 /**
- * Class interval for periodic execution of the callback in time in ms
+ * Class periodic for periodic execution of the callback in time in ms
 */
-class interval {
+class periodic {
     shared_ptr<timer> _timer;
 
     public:
     /**
      * Constructor initializes a shared pointer of type timer
     */
-    interval(function<void()> callback, uint64_t time) : 
+    periodic(function<void()> callback, uint64_t time) : 
         _timer(make_shared<timer> (callback, time, true)) {
     }
 
     /**
-     * Stop interval
-     * The stop flag is set and interval remove it from the queue
+     * Stop periodic
+     * The stop flag is set and periodic remove it from the queue
     */
     void stop() {
         _timer->stop();
@@ -136,51 +136,51 @@ class interval {
 
     /**
      * Run callback now
-     * Forces the callback function to run independently of the interval
+     * Forces the callback function to run independently of the periodic
     */
     void now() {
         _timer->now();
     }
     
     /**
-     * Get the number of times the interval callback was runned
+     * Get the number of times the periodic callback was runned
     */
     uint64_t ticks() {
         return _timer->ticks();
     }
 
     /**
-     * The logic status of the interval stop state
+     * The logic status of the periodic stop state
     */
     bool stoped() {
         return _timer->stoped();
     }
     
     /**
-     * The destructor stops the interval
+     * The destructor stops the periodic
     */
-    ~interval() {
+    ~periodic() {
         stop();
     }
 };
 
 /**
- * Class timeout for delayed callback execution in ms
+ * Class delayed for delayed callback execution in ms
 */
-class timeout {
+class delayed {
     shared_ptr<timer> _timer;
 
     public:
     /**
      * Constructor initializes a shared pointer of type timer
     */
-    timeout(function<void()> callback, uint64_t time) : 
+    delayed(function<void()> callback, uint64_t time) : 
         _timer(make_shared<timer> (callback, time, false)) {
     }
     
     /**
-     * Stop timeout
-     * The stop flag is set and timeout remove it from the queue
+     * Stop delayed
+     * The stop flag is set and delayed remove it from the queue
     */
     void stop() {
         _timer->stop();
@@ -188,30 +188,30 @@ class timeout {
 
     /**
      * Run callback now
-     * Forces the callback function to run independently of the timeout
+     * Forces the callback function to run independently of the delayed
     */
     void now() {
         _timer->now();
     }
 
     /**
-     * Get the number of times the timeout callback was runned
+     * Get is the delayed callback runned
     */
     bool expired() {
         return bool(_timer->ticks());
     }
 
     /**
-     * The logic status of the timeout stop state
+     * The logic status of the delayed stop state
     */
     bool stoped() {
         return _timer->stoped();
     }
 
     /**
-     * The destructor stops the timeout
+     * The destructor stops the delayed
     */
-    ~timeout() {
+    ~delayed() {
         stop();
     }
 

lib/trigger.hpp

@@ -0,0 +1,92 @@
+#ifndef _TRIGGER_
+#define _TRIGGER_
+
+#include <map>
+#include <vector>
+#include <string>
+#include <functional>
+
+using namespace std;
+
+#include "asynco.hpp"
+namespace marcelb {
+namespace asynco {
+namespace triggers {
+
+/**
+ * trigger class, for event-driven programming.
+ * These events are typed according to the arguments of the callback function
+*/
+template<typename... T>
+class trigger {
+    private:
+    mutex m_eve;
+    unordered_map<string, vector<function<void(T...)>>> triggers;
+
+    public:
+
+    /**
+     * Defines event by key, and callback function
+    */
+    void on(const string& key, function<void(T...)> callback) {
+        lock_guard _off(m_eve);
+        triggers[key].push_back(callback);
+    }
+
+    /**
+     * It emits an event and sends a callback function saved according to the key with the passed parameters
+    */
+    template<typename... Args>
+    void tick(const string& key, Args... args) {
+        auto it_eve = triggers.find(key);
+        if (it_eve != triggers.end()) {
+            for (uint i =0; i<it_eve->second.size(); i++) {
+                auto callback = bind(it_eve->second[i], forward<Args>(args)...); 
+                atask(callback);
+            }
+        }
+    }
+
+    /**
+     * Remove an trigger listener from an event
+    */
+    void off(const string& key) {
+        lock_guard _off(m_eve);
+        triggers.erase(key);
+    }
+
+    /**
+     * Remove all trigger listener
+    */
+    void off() {
+        lock_guard _off(m_eve);
+        triggers.clear();
+    }
+
+
+    /**
+     * Get num of listeners by an trigger key
+    */
+    unsigned int listeners(const string& key) {
+        return triggers[key].size();
+    }
+
+    /**
+     * Get num of all listeners
+    */
+    unsigned int listeners() {
+        unsigned int listeners = 0;
+        for (auto& ev : triggers) {
+            listeners += ev.second.size();
+        }
+        return listeners;
+    }
+
+
+};
+
+}
+}
+}
+
+#endif

test/test.cpp

@@ -1,12 +1,12 @@
-// #define NUM_OF_RUNNERS 2
+// // #define NUM_OF_RUNNERS 2
 
 #include "../lib/asynco.hpp"
-#include "../lib/event.hpp"
+#include "../lib/trigger.hpp"
 #include "../lib/filesystem.hpp"
 #include "../lib/timers.hpp"
 
 using namespace marcelb::asynco;
-using namespace events;
+using namespace triggers;
 
 #include <iostream>
 #include <unistd.h>
@@ -18,7 +18,7 @@ using namespace this_thread;
 
 void sleep_to (int _time) {
     promise<void> _promise;
-    timeout t( [&]() {
+    delayed t( [&]() {
         _promise.set_value();
     }, _time);
 
@@ -27,7 +27,7 @@ void sleep_to (int _time) {
 
 void promise_reject (int _time) {
     promise<void> _promise;
-    timeout t( [&]() {
+    delayed t( [&]() {
         try {
             // simulate except
             throw runtime_error("Error simulation");
@@ -53,9 +53,9 @@ class clm {
 
 // ------------------ EXTEND OWN CLASS WITH EVENTS -------------------
 
-class myOwnClass : public event<int> {
+class myOwnClass : public trigger<int> {
     public:
-    myOwnClass() : event() {};
+    myOwnClass() : trigger() {};
 };
 
 
@@ -66,36 +66,36 @@ int main () {
     // --------------- TIME ASYNCHRONOUS FUNCTIONS --------------
 
     // /**
-    //  * Init interval and timeout; clear interval and timeout
+    //  * Init periodic and delayed; clear periodic and delayed
     // */
 
-    // interval inter1 ([&]() {
-    //     cout << "interval prvi " << rtime_ms() - start << endl;
+    // periodic inter1 ([&]() {
+    //     cout << "periodic prvi " << rtime_ms() - start << endl;
     // }, 1000);
 
-    // interval inter2 ([&]() {
-    //     cout << "interval drugi " << rtime_ms() - start << endl;
+    // periodic inter2 ([&]() {
+    //     cout << "periodic drugi " << rtime_ms() - start << endl;
     // }, 2000);
 
-    // interval inter3 ([&]() {
-    //     cout << "interval treći " << rtime_ms() - start << endl;
+    // periodic inter3 ([&]() {
+    //     cout << "periodic treći " << rtime_ms() - start << endl;
     // }, 1000);
 
-    // interval inter4 ([&]() {
-    //     // cout << "interval cetvrti " << rtime_ms() - start << endl;
+    // periodic inter4 ([&]() {
+    //     // cout << "periodic cetvrti " << rtime_ms() - start << endl;
     //     cout << "Ticks " << inter3.ticks() << endl;
     // }, 500);
 
-    // interval inter5 ([&]() {
-    //     cout << "interval peti " << rtime_ms() - start << endl;
+    // periodic inter5 ([&]() {
+    //     cout << "periodic peti " << rtime_ms() - start << endl;
     // }, 2000);
 
-    // interval inter6 ([&]() {
-    //     cout << "interval sesti " << rtime_ms() - start << endl;
+    // periodic inter6 ([&]() {
+    //     cout << "periodic sesti " << rtime_ms() - start << endl;
     // }, 3000);
 
-    // timeout time1 ( [&] () {
-    //     cout << "Close interval 1 i 2 " << rtime_ms() - start << endl;
+    // delayed time1 ( [&] () {
+    //     cout << "Close periodic 1 i 2 " << rtime_ms() - start << endl;
     //     inter1.stop();
     //     cout << "inter1.stop " << endl;
     //     inter2.stop();
@@ -103,8 +103,8 @@ int main () {
     // }, 8000);
 
 
-    // timeout time2 ([&] () {
-    //     cout << "Close interval 3 " << rtime_ms() - start << endl;
+    // delayed time2 ([&] () {
+    //     cout << "Close periodic 3 " << rtime_ms() - start << endl;
     //     inter3.stop();
     //     cout << "Stoped " << inter3.stoped() << endl;
     //     // time1.stop();
@@ -185,7 +185,7 @@ int main () {
     // })) << endl;
 
     // /**
-    //  * Sleep with timeout sleep implement
+    //  * Sleep with delayed sleep implement
     // */
 
     // sleep_to(3000);
@@ -216,68 +216,74 @@ int main () {
     //     });
     // });
 
-    // // // --------------- EVENTS -------------------
+    // --------------- EVENTS -------------------
 
-    // /**
-    //  * initialization of typed events
-    // */
+    /**
+     * initialization of typed events
+    */
 
-    // event<int, int> ev2int;
-    // event<int, string> evintString;
-    // event<> evoid;
+    trigger<int, int> ev2int;
+    trigger<int, string> evintString;
+    trigger<> evoid;
 
-    // ev2int.on("sum", [](int a, int b) {
-    //     cout << "Sum " << a+b << endl;
-    // });
+    ev2int.on("sum", [](int a, int b) {
+        cout << "Sum " << a+b << endl;
+    });
 
-    // ev2int.on("sum", [](int a, int b) {
-    //     cout << "Sum done" << endl;
-    // });
+    ev2int.on("sum", [](int a, int b) {
+        cout << "Sum done" << endl;
+    });
 
-    // evintString.on("substract", [](int a, string b) {
-    //     cout << "Substract " << a-stoi(b) << endl;
-    // });
+    evintString.on("substract", [](int a, string b) {
+        cout << "Substract " << a-stoi(b) << endl;
+    });
 
-    // evoid.on("void", []() {
-    //     cout << "Void emited" << endl;
-    // });
+    evoid.on("void", []() {
+        cout << "Void emited" << endl;
+    });
 
-    // string emited2 = "2";
+    string emited2 = "2";
 
-    // evoid.on("void", [&]() {
-    //     cout << "Void emited " << emited2 << endl;
-    // });
+    evoid.on("void", [&]() {
+        cout << "Void emited " << emited2 << endl;
+    });
 
-    // evoid.emit("void");
-    // sleep(1);
+    evoid.tick("void");
+    sleep(1);
 
-    // /**
-    //  * Emit
-    // */
+    /**
+     * Emit
+    */
 
-    // ev2int.emit("sum", 5, 8);
+    ev2int.tick("sum", 5, 8);
     
 
-    // sleep(1);
-    // evintString.emit("substract", 3, to_string(2));
+    sleep(1);
+    evintString.tick("substract", 3, to_string(2));
 
-    // sleep(1);
-    // evoid.off("void");
-    // evoid.emit("void");
+    sleep(1);
+    evoid.off("void");
+    evoid.tick("void");
 
-    // /**
-    //  * Own class 
-    // */
 
-    // myOwnClass myclass;
+    cout << "Ukupno 2 int " <<  ev2int.listeners() << endl;
+    cout << "Ukupno evintString " <<  evintString.listeners() << endl;
+    cout << "Ukupno evoid " <<  evoid.listeners() << endl;
+    cout << "Ukupno 2 int " <<  ev2int.listeners("sum") << endl;
 
-    // timeout t( [&] {
-    //     myclass.emit("constructed", 1);
-    // }, 200);
+    /**
+     * Own class 
+    */
 
-    // myclass.on("constructed", [] (int i) {
-    //     cout << "Constructed " << i  << endl;
-    // });
+    myOwnClass myclass;
+
+    delayed t( [&] {
+        myclass.tick("constructed", 1);
+    }, 200);
+
+    myclass.on("constructed", [] (int i) {
+        cout << "Constructed " << i  << endl;
+    });
 
 
 
@@ -307,7 +313,7 @@ int main () {
     // });
 
 
-    // ----------------------------------------------------------------------------------------------------
+    // // ----------------------------------------------------------------------------------------------------
 
     cout << "Run" << endl;
     _asynco_engine.run();