marcelb
/
asynco
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Rename, add listeners, off all, edit readme

Browse Source
dev 0.3
marcelb 5 months ago
parent e91c7f646d
commit 22dbfe89f1
4 changed files with 254 additions and 215 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 36
      README.md
  2. 27
      lib/event.hpp
  3. 44
      lib/timers.hpp
  4. 362
      test/test.cpp

36
README.md
Unescape View File

@ -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,7 +16,7 @@ A C++ library for event-driven asynchronous multi-threaded programming.
- Header only
- Asynchronous programming
- Multithread
- Asynchronous timer functions: interval, timeout
- Asynchronous timer functions: periodic, delayed (like setInterval and setTimeout from JS)
- Typed events (on, emit, off)
- Event loops
- Multiple parallel execution loops
@ -23,10 +29,10 @@ 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/event.hpp" // event
#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;
@ -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");
@ -237,7 +243,7 @@ class myOwnClass : public event<int> {
myOwnClass myclass;
timeout t( [&] {
delayed t( [&] {
myclass.emit("constructed", 1);
}, 200);

27
lib/event.hpp
Unescape View File

@ -55,6 +55,33 @@ class event {
events.erase(key);
}
/**
* Remove all event listener
*/
void off() {
lock_guard _off(m_eve);
events.clear();
}
/**
* Get num of listeners by an event key
*/
unsigned int listeners(const string& key) {
return events[key].size();
}
/**
* Get num of all listeners
*/
unsigned int listeners() {
unsigned int listeners = 0;
for (auto& ev : events) {
listeners += ev.second.size();
}
return listeners;
}
};

44
lib/timers.hpp
Unescape View File

@ -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();
}

362
test/test.cpp
Unescape View File

@ -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");
@ -65,249 +65,255 @@ 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;
}, 1000);
// periodic inter1 ([&]() {
// cout << "periodic prvi " << rtime_ms() - start << endl;
// }, 1000);
interval inter2 ([&]() {
cout << "interval drugi " << rtime_ms() - start << endl;
}, 2000);
// periodic inter2 ([&]() {
// cout << "periodic drugi " << rtime_ms() - start << endl;
// }, 2000);
interval inter3 ([&]() {
cout << "interval treći " << rtime_ms() - start << endl;
}, 1000);
// periodic inter3 ([&]() {
// cout << "periodic treći " << rtime_ms() - start << endl;
// }, 1000);
interval inter4 ([&]() {
// cout << "interval cetvrti " << rtime_ms() - start << endl;
cout << "Ticks " << inter3.ticks() << endl;
}, 500);
// periodic inter4 ([&]() {
// // cout << "periodic cetvrti " << rtime_ms() - start << endl;
// cout << "Ticks " << inter3.ticks() << endl;
// }, 500);
interval inter5 ([&]() {
cout << "interval peti " << rtime_ms() - start << endl;
}, 2000);
// periodic inter5 ([&]() {
// cout << "periodic peti " << rtime_ms() - start << endl;
// }, 2000);
interval inter6 ([&]() {
cout << "interval sesti " << rtime_ms() - start << endl;
}, 3000);
// periodic inter6 ([&]() {
// cout << "periodic sesti " << rtime_ms() - start << endl;
// }, 3000);
timeout time1 ( [&] () {
cout << "Close interval 1 i 2 " << rtime_ms() - start << endl;
inter1.stop();
cout << "inter1.stop " << endl;
inter2.stop();
cout << "inter2.stop " << endl;
}, 8000);
// delayed time1 ( [&] () {
// cout << "Close periodic 1 i 2 " << rtime_ms() - start << endl;
// inter1.stop();
// cout << "inter1.stop " << endl;
// inter2.stop();
// cout << "inter2.stop " << endl;
// }, 8000);
timeout time2 ([&] () {
cout << "Close interval 3 " << rtime_ms() - start << endl;
inter3.stop();
cout << "Stoped " << inter3.stoped() << endl;
// time1.stop();
}, 5000);
// delayed time2 ([&] () {
// cout << "Close periodic 3 " << rtime_ms() - start << endl;
// inter3.stop();
// cout << "Stoped " << inter3.stoped() << endl;
// // time1.stop();
// }, 5000);
if (time2.expired()) {
cout << "isteko " << endl;
} else {
cout << "nije isteko " << endl;
}
// if (time2.expired()) {
// cout << "isteko " << endl;
// } else {
// cout << "nije isteko " << endl;
// }
// sleep(6);
// // sleep(6);
if (time2.expired()) {
cout << "isteko " << endl;
} else {
cout << "nije isteko " << endl;
}
// if (time2.expired()) {
// cout << "isteko " << endl;
// } else {
// cout << "nije isteko " << endl;
// }
// // ------------------------ MAKE FUNCTIONS ASYNCHRONOUS -------------------------
// // // ------------------------ MAKE FUNCTIONS ASYNCHRONOUS -------------------------
/**
* Run an function asyncronic
*/
// /**
// * Run an function asyncronic
// */
atask( []() {
sleep_for(2s); // only for simulate log duration function
cout << "atask 1" << endl;
return 5;
});
// atask( []() {
// sleep_for(2s); // only for simulate log duration function
// cout << "atask 1" << endl;
// return 5;
// });
/**
* Call not lambda function
*/
// /**
// * Call not lambda function
// */
atask (notLambdaFunction);
// atask (notLambdaFunction);
wait (
atask (
notLambdaFunction
)
);
// wait (
// atask (
// notLambdaFunction
// )
// );
/**
* Call class method
*/
// /**
// * Call class method
// */
clm classes;
atask( [&classes] () {
classes.classMethode();
});
// clm classes;
// atask( [&classes] () {
// classes.classMethode();
// });
sleep(5);
// sleep(5);
/**
* Wait after runned as async
*/
// /**
// * Wait after runned as async
// */
auto a = atask( []() {
sleep_for(2s); // only for simulate log duration function
cout << "atask 2" << endl;
return 5;
});
// auto a = atask( []() {
// sleep_for(2s); // only for simulate log duration function
// cout << "atask 2" << endl;
// return 5;
// });
cout << wait(a) << endl;
cout << "print after atask 2" << endl;
// cout << wait(a) << endl;
// cout << "print after atask 2" << endl;
/**
* Wait async function call and use i cout
*/
// /**
// * Wait async function call and use i cout
// */
cout << wait(atask( [] () {
sleep_for(chrono::seconds(1)); // only for simulate log duration function
cout << "wait end" << endl;
return 4;
})) << endl;
// cout << wait(atask( [] () {
// sleep_for(chrono::seconds(1)); // only for simulate log duration function
// cout << "wait end" << endl;
// return 4;
// })) << endl;
/**
* Sleep with timeout sleep implement
*/
// /**
// * Sleep with delayed sleep implement
// */
sleep_to(3000);
cout << "sleep_to " << rtime_ms() - start << endl;
// sleep_to(3000);
// cout << "sleep_to " << rtime_ms() - start << endl;
/**
* Catch promise reject
*/
// /**
// * Catch promise reject
// */
try {
promise_reject(3000);
} catch (runtime_error err) {
cout<< err.what() << endl;
}
// try {
// promise_reject(3000);
// } catch (runtime_error err) {
// cout<< err.what() << endl;
// }
cout << "promise_reject " << rtime_ms() - start << endl;
// cout << "promise_reject " << rtime_ms() - start << endl;
/**
* Nested asynchronous invocation
*/
// /**
// * Nested asynchronous invocation
// */
atask( [] {
cout << "idemo ..." << endl;
atask( [] {
cout << "ugdnježdena async funkcija " << endl;
});
});
// atask( [] {
// cout << "idemo ..." << endl;
// atask( [] {
// cout << "ugdnježdena async funkcija " << endl;
// });
// });
// // --------------- EVENTS -------------------
/**
* initialization of typed events
*/
// /**
// * initialization of typed events
// */
event<int, int> ev2int;
event<int, string> evintString;
event<> evoid;
// event<int, int> ev2int;
// event<int, string> evintString;
// event<> 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.emit("void");
// sleep(1);
/**
* Emit
*/
// /**
// * Emit
// */
ev2int.emit("sum", 5, 8);
// ev2int.emit("sum", 5, 8);
sleep(1);
evintString.emit("substract", 3, to_string(2));
// sleep(1);
// evintString.emit("substract", 3, to_string(2));
sleep(1);
evoid.off("void");
evoid.emit("void");
// sleep(1);
// evoid.off("void");
// evoid.emit("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.emit("constructed", 1);
// }, 200);
// myclass.on("constructed", [] (int i) {
// cout << "Constructed " << i << endl;
// });
auto status = fs::read("test1.txt");
try {
auto data = wait(status);
cout << data;
} catch (exception& err) {
cout << err.what() << endl;
}
// auto status = fs::read("test1.txt");
string data_;
auto start_read = rtime_us();
// try {
// auto data = wait(status);
// cout << data;
// } catch (exception& err) {
// cout << err.what() << endl;
// }
fs::read("test1.txt", [&data_, &start_read] (string data, exception* error) {
if (error) {
cout << "Error " << error->what() << endl;
} else {
// cout << "Data " << endl << data << endl;
// data_ = data;
// cout << "Data_" << data_ << endl;
cout << "read " << rtime_us() - start_read << endl;
}
});
// string data_;
// auto start_read = rtime_us();
// fs::read("test1.txt", [&data_, &start_read] (string data, exception* error) {
// if (error) {
// cout << "Error " << error->what() << endl;
// } else {
// // cout << "Data " << endl << data << endl;
// // data_ = data;
// // cout << "Data_" << data_ << endl;
// cout << "read " << rtime_us() - start_read << endl;
// }
// });
// ----------------------------------------------------------------------------------------------------
// // ----------------------------------------------------------------------------------------------------
cout << "Run" << endl;
_asynco_engine.run();

Write Preview
Loading…
Cancel
Save