Compare commits
No commits in common. "dev" and "multiple_init_problem" have entirely different histories.
dev
...
multiple_i
5
.gitignore
vendored
5
.gitignore
vendored
@ -1,3 +1,2 @@
|
||||
build
|
||||
.vscode
|
||||
example
|
||||
test/test
|
||||
test/*.txt
|
||||
16
.vscode/c_cpp_properties.json
vendored
Normal file
16
.vscode/c_cpp_properties.json
vendored
Normal file
@ -0,0 +1,16 @@
|
||||
{
|
||||
"configurations": [
|
||||
{
|
||||
"name": "Linux",
|
||||
"includePath": [
|
||||
"${workspaceFolder}/**"
|
||||
],
|
||||
"defines": [],
|
||||
"compilerPath": "/usr/bin/gcc",
|
||||
"cStandard": "c17",
|
||||
"cppStandard": "gnu++17",
|
||||
"intelliSenseMode": "linux-gcc-x64"
|
||||
}
|
||||
],
|
||||
"version": 4
|
||||
}
|
||||
76
.vscode/settings.json
vendored
Normal file
76
.vscode/settings.json
vendored
Normal file
@ -0,0 +1,76 @@
|
||||
{
|
||||
"files.associations": {
|
||||
"iostream": "cpp",
|
||||
"functional": "cpp",
|
||||
"thread": "cpp",
|
||||
"chrono": "cpp",
|
||||
"ostream": "cpp",
|
||||
"condition_variable": "cpp",
|
||||
"array": "cpp",
|
||||
"atomic": "cpp",
|
||||
"cwchar": "cpp",
|
||||
"deque": "cpp",
|
||||
"unordered_map": "cpp",
|
||||
"vector": "cpp",
|
||||
"exception": "cpp",
|
||||
"initializer_list": "cpp",
|
||||
"iosfwd": "cpp",
|
||||
"mutex": "cpp",
|
||||
"new": "cpp",
|
||||
"ratio": "cpp",
|
||||
"stdexcept": "cpp",
|
||||
"tuple": "cpp",
|
||||
"type_traits": "cpp",
|
||||
"utility": "cpp",
|
||||
"future": "cpp",
|
||||
"*.ipp": "cpp",
|
||||
"bitset": "cpp",
|
||||
"algorithm": "cpp",
|
||||
"string": "cpp",
|
||||
"string_view": "cpp",
|
||||
"fstream": "cpp",
|
||||
"cctype": "cpp",
|
||||
"clocale": "cpp",
|
||||
"cmath": "cpp",
|
||||
"csignal": "cpp",
|
||||
"cstdarg": "cpp",
|
||||
"cstddef": "cpp",
|
||||
"cstdio": "cpp",
|
||||
"cstdlib": "cpp",
|
||||
"cstring": "cpp",
|
||||
"ctime": "cpp",
|
||||
"cwctype": "cpp",
|
||||
"any": "cpp",
|
||||
"bit": "cpp",
|
||||
"*.tcc": "cpp",
|
||||
"codecvt": "cpp",
|
||||
"compare": "cpp",
|
||||
"complex": "cpp",
|
||||
"concepts": "cpp",
|
||||
"cstdint": "cpp",
|
||||
"list": "cpp",
|
||||
"map": "cpp",
|
||||
"set": "cpp",
|
||||
"iterator": "cpp",
|
||||
"memory": "cpp",
|
||||
"memory_resource": "cpp",
|
||||
"numeric": "cpp",
|
||||
"optional": "cpp",
|
||||
"random": "cpp",
|
||||
"system_error": "cpp",
|
||||
"iomanip": "cpp",
|
||||
"istream": "cpp",
|
||||
"limits": "cpp",
|
||||
"numbers": "cpp",
|
||||
"semaphore": "cpp",
|
||||
"sstream": "cpp",
|
||||
"stop_token": "cpp",
|
||||
"streambuf": "cpp",
|
||||
"cinttypes": "cpp",
|
||||
"typeindex": "cpp",
|
||||
"typeinfo": "cpp",
|
||||
"variant": "cpp",
|
||||
"coroutine": "cpp",
|
||||
"source_location": "cpp"
|
||||
}
|
||||
}
|
||||
28
.vscode/tasks.json
vendored
Normal file
28
.vscode/tasks.json
vendored
Normal file
@ -0,0 +1,28 @@
|
||||
{
|
||||
"tasks": [
|
||||
{
|
||||
"type": "cppbuild",
|
||||
"label": "C/C++: gcc build active file",
|
||||
"command": "/usr/bin/g++",
|
||||
"args": [
|
||||
"-fdiagnostics-color=always",
|
||||
"-g",
|
||||
"${file}",
|
||||
"-o",
|
||||
"${fileDirname}/${fileBasenameNoExtension}"
|
||||
],
|
||||
"options": {
|
||||
"cwd": "${fileDirname}"
|
||||
},
|
||||
"problemMatcher": [
|
||||
"$gcc"
|
||||
],
|
||||
"group": {
|
||||
"kind": "build",
|
||||
"isDefault": true
|
||||
},
|
||||
"detail": "Task generated by Debugger."
|
||||
}
|
||||
],
|
||||
"version": "2.0.0"
|
||||
}
|
||||
@ -1,35 +0,0 @@
|
||||
cmake_minimum_required(VERSION 3.10)
|
||||
|
||||
project(Asynco)
|
||||
|
||||
# Postavi verziju projekta
|
||||
set(CMAKE_CXX_STANDARD 20)
|
||||
set(CMAKE_CXX_STANDARD_REQUIRED ON)
|
||||
|
||||
# Pronađi Boost biblioteku (ako nije uobičajeni direktorijum, postavi put)
|
||||
find_package(Boost REQUIRED COMPONENTS system)
|
||||
|
||||
# Dodaj direktorijume sa zaglavljima
|
||||
include_directories(lib)
|
||||
|
||||
# Dodaj biblioteku
|
||||
add_library(asynco STATIC
|
||||
src/asynco.cpp
|
||||
src/asynco_default.cpp
|
||||
src/timers.cpp
|
||||
)
|
||||
|
||||
# Linkaj Asynco biblioteku sa Boost-om
|
||||
target_link_libraries(asynco Boost::system)
|
||||
|
||||
# Dodaj testove
|
||||
add_subdirectory(test)
|
||||
|
||||
add_compile_options(-w)
|
||||
|
||||
|
||||
|
||||
# Instaliraj biblioteku
|
||||
# install(TARGETS asynco DESTINATION lib)
|
||||
# install(FILES lib/asynco.hpp lib/define.hpp lib/engine.hpp lib/filesystem.hpp lib/timers.hpp lib/trigger.hpp DESTINATION include/asynco)
|
||||
#
|
||||
336
README.md
336
README.md
@ -1,89 +1,59 @@
|
||||
|
||||
# Asynco
|
||||
|
||||
A C++ library for event-driven asynchronous multi-threaded programming that serves as a runtime for asynchronous operations. It acts as a wrapper around the Boost.Asio library, providing a cleaner way to write asynchronous, concurrent, and parallel code utilizing a set of threads and an event loops. It offers features for event-driven programming, timers, and coroutine support.
|
||||
A C++ library for event-driven asynchronous multi-threaded programming.
|
||||
|
||||
## Motivation
|
||||
|
||||
The initial goal was to create an interface that makes it easy and clean to asynchronously invoke any function in C++ without resorting to complex calls. Initially, the library was built around a custom implementation of a scheduling loop for queuing functions. However, this part was later replaced with Boost.Asio, mainly for its timer functionality. As the library evolved, it expanded to include a thread pool, each with its own event loop, and adopted event-driven programming. This enhancement also introduced functions specifically designed for asynchronous operations, including periodic and delayed execution.
|
||||
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 was included solely to demonstrate how users can wrap any time- or I/O-intensive functions for asynchronous execution.
|
||||
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
|
||||
- Small and easy to integrate
|
||||
- Header only
|
||||
- Asynchronous programming
|
||||
- Multithread
|
||||
- Asynchronous timer functions: Periodic, Delayed (like setInterval and setTimeout from JS)
|
||||
- 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
|
||||
- Based on ASIO (Boost Asio)
|
||||
- On C++20 support Boost.Asio coroutines
|
||||
## Installation
|
||||
|
||||
Just download the latest release and unzip it into your project.
|
||||
|
||||
```c++
|
||||
// for default global runtime
|
||||
|
||||
#include "asynco/lib/asynco_default.hpp"
|
||||
#define NUM_OF_RUNNERS 8 // To change the number of threads used by asynco, without this it runs according to the number of cores
|
||||
|
||||
#include "asynco/lib/asynco.hpp" // async_ (), await_()
|
||||
#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 triggers;
|
||||
|
||||
int main() {
|
||||
asynco_default_run();
|
||||
|
||||
// code
|
||||
|
||||
asynco_default_join()
|
||||
return 0;
|
||||
}
|
||||
|
||||
// own instace of runtime
|
||||
|
||||
#include "asynco/lib/asynco.hpp"
|
||||
|
||||
using namespace marcelb;
|
||||
using namespace asynco;
|
||||
|
||||
int main() {
|
||||
Asynco asynco;
|
||||
asynco.run(2);
|
||||
|
||||
// code
|
||||
|
||||
asynco.join();
|
||||
return 0;
|
||||
}
|
||||
// At the end of the main function, always set
|
||||
_asynco_engine.run();
|
||||
return 0;
|
||||
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
In the following sections, we will explore timers, function execution via the runtime, asynchronous invocation, and waiting for results. We will cover essential use cases involving triggers, and coroutines.
|
||||
|
||||
### Timers
|
||||
|
||||
We have one timer classes, int two mode Periodic (which runs a callback function periodically), and Delayed (delayed runs a callback function only once).
|
||||
Time asynchronous functions
|
||||
|
||||
```c++
|
||||
// start periodic
|
||||
Timer inter1 = periodic ([]() {
|
||||
periodic inter1 ([]() {
|
||||
cout << "Interval 1" << endl;
|
||||
}, 1000);
|
||||
|
||||
// or usint own instance runtime
|
||||
/**
|
||||
* Asynco asynco;
|
||||
* asynco.run(2);
|
||||
* Timer inter1 = asynco.periodic ([]() {
|
||||
* cout << "Interval 1" << endl;
|
||||
* }, 1000);
|
||||
*/
|
||||
// stop periodic
|
||||
inter1.stop();
|
||||
|
||||
@ -94,7 +64,7 @@ int t = inter1.ticks();
|
||||
bool stoped = inter1.stoped();
|
||||
|
||||
// start delayed
|
||||
Timer time1 = delayed( [] () {
|
||||
delayed time1 ( [] () {
|
||||
cout << "Timeout 1 " << endl;
|
||||
}, 10000);
|
||||
|
||||
@ -107,10 +77,30 @@ int t = time1.expired();
|
||||
// is it stopped
|
||||
bool stoped = time1.stoped();
|
||||
|
||||
```
|
||||
### Make functions asynchronous
|
||||
// If you don't want to save in a variable, but you want to start a timer, use these functions
|
||||
// And you can also save them, they are only of the shared pointer type
|
||||
|
||||
Running functions at runtime, asynchronous execution, uses the `async_` call and its return type is `std::future<T>`
|
||||
auto d = Delayed( [](){
|
||||
cout << "Delayed" << endl;
|
||||
}, 2000);
|
||||
|
||||
auto p = Periodic( [](){
|
||||
cout << "Periodic" << endl;
|
||||
}, 700);
|
||||
|
||||
Periodic( [&] (){
|
||||
cout << "Delayed expire " << d->expired() << endl;
|
||||
cout << "Periodic ticks " << p->ticks() << endl;
|
||||
cout << "Delayed stoped " << d->stoped() << endl;
|
||||
cout << "Periodic stoped " << p->stoped() << endl;
|
||||
}, 1000);
|
||||
|
||||
Delayed( [&](){
|
||||
p->stop();
|
||||
}, 10000);
|
||||
|
||||
```
|
||||
Make functions asynchronous
|
||||
|
||||
```c++
|
||||
/**
|
||||
@ -118,7 +108,7 @@ Running functions at runtime, asynchronous execution, uses the `async_` call and
|
||||
*/
|
||||
|
||||
async_ ( []() {
|
||||
sleep(2); // only for simulating long duration function
|
||||
sleep_for(2s); // only for simulating long duration function
|
||||
cout << "nonsync " << endl;
|
||||
return 5;
|
||||
});
|
||||
@ -149,14 +139,15 @@ clm classes;
|
||||
async_ ( [&classes] () {
|
||||
classes.classMethode();
|
||||
});
|
||||
```
|
||||
|
||||
To wait for the result (blocking the flow) use `await_` (This does not block the event loop in principle. If the result is not ready for a short time, it starts another job in place while it waits.)
|
||||
|
||||
```c++
|
||||
|
||||
/**
|
||||
* await_ after runned as async
|
||||
*/
|
||||
|
||||
auto a = async_ ( []() {
|
||||
sleep(2); // only for simulating long duration function
|
||||
sleep_for(2s); // only for simulating long duration function
|
||||
cout << "nonsync " << endl;
|
||||
return 5;
|
||||
});
|
||||
@ -168,36 +159,115 @@ cout << await_(a) << endl;
|
||||
*/
|
||||
|
||||
cout << await_(async_ ( [] () {
|
||||
sleep(1); // only for simulating long duration function
|
||||
sleep_for(chrono::seconds(1)); // only for simulating long duration function
|
||||
cout << "await_ end" << endl;
|
||||
return 4;
|
||||
})) << endl;
|
||||
|
||||
```
|
||||
|
||||
If you want to run asynchronously but need the result immediately, you can use a shorter notation
|
||||
/**
|
||||
* Await all
|
||||
**/
|
||||
|
||||
```c++
|
||||
|
||||
await_ ([]() {
|
||||
cout << "Hello" << endl;
|
||||
auto a = async_ ( []() {
|
||||
cout << "A" << endl;
|
||||
return 3;
|
||||
});
|
||||
|
||||
auto b = async_ ( []() {
|
||||
cout << "B" << endl;
|
||||
throw runtime_error("Test exception");
|
||||
return;
|
||||
});
|
||||
|
||||
auto c = async_ ( []() {
|
||||
cout << "C" << endl;
|
||||
return "Hello";
|
||||
});
|
||||
|
||||
int a_;
|
||||
string c_;
|
||||
|
||||
auto await_all = [&] () {
|
||||
a_ = await_(a);
|
||||
await_(b);
|
||||
c_ = await_(c);
|
||||
};
|
||||
|
||||
try {
|
||||
await_all();
|
||||
cout << "a_ " << a_ << " c_ " << c_ << endl;
|
||||
} catch (const exception& exc) {
|
||||
cout << exc.what() << endl;
|
||||
}
|
||||
|
||||
// // same type
|
||||
|
||||
vector<future<void>> fut_vec;
|
||||
for (int i=0; i<5; i++) {
|
||||
fut_vec.push_back(
|
||||
async_ ( [i]() {
|
||||
cout << "Async_ " << i << endl;
|
||||
})
|
||||
);
|
||||
}
|
||||
|
||||
auto await_all = [&] () {
|
||||
for (int i=0; i<fut_vec.size(); i++) {
|
||||
await_ (fut_vec[i]);
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Sleep with delayed sleep implement
|
||||
*/
|
||||
|
||||
void sleep_to (int _time) {
|
||||
promise<void> _promise;
|
||||
delayed t( [&]() {
|
||||
_promise.set_value();
|
||||
}, _time);
|
||||
|
||||
return _promise.get_future().get();
|
||||
}
|
||||
|
||||
sleep_to(3000);
|
||||
|
||||
/**
|
||||
* Catch promise reject
|
||||
*/
|
||||
|
||||
void promise_reject (int _time) {
|
||||
promise<void> _promise;
|
||||
delayed t( [&]() {
|
||||
try {
|
||||
// simulate except
|
||||
throw runtime_error("Error simulation");
|
||||
_promise.set_value();
|
||||
} catch (...) {
|
||||
_promise.set_exception(current_exception());
|
||||
}
|
||||
}, _time);
|
||||
|
||||
return _promise.get_future().get();
|
||||
}
|
||||
|
||||
try {
|
||||
promise_reject(3000);
|
||||
} catch (runtime_error err) {
|
||||
cout<< err.what() << endl;
|
||||
}
|
||||
```
|
||||
Here too you can use your own runtime instance, only the methods are `.async()` and `.await()`
|
||||
|
||||
### Triggers
|
||||
|
||||
The library implements Triggers, which are basically typed Events.
|
||||
Events
|
||||
|
||||
```c++
|
||||
/**
|
||||
* initialization of typed events
|
||||
*/
|
||||
|
||||
Trigger<int, int> ev2int = trigger<int, int>();
|
||||
Trigger<int, string> evintString = trigger<int, string>();
|
||||
Trigger<> evoid = trigger<>();
|
||||
trigger<int, int> ev2int;
|
||||
trigger<int, string> evintString;
|
||||
trigger<> evoid;
|
||||
|
||||
ev2int.on("sum", [](int a, int b) {
|
||||
cout << "Sum " << a+b << endl;
|
||||
@ -242,14 +312,14 @@ evoid.tick("void"); // nothing is happening
|
||||
Extend own class whit events
|
||||
|
||||
```c++
|
||||
class myOwnClass : public Trigger<int> {
|
||||
class myOwnClass : public trigger<int> {
|
||||
public:
|
||||
myOwnClass() : Trigger(asynco_default_runtime()) {};
|
||||
myOwnClass() : trigger() {};
|
||||
};
|
||||
|
||||
myOwnClass myclass;
|
||||
|
||||
Delayed t( [&] {
|
||||
delayed t( [&] {
|
||||
myclass.tick("constructed", 1);
|
||||
}, 200);
|
||||
|
||||
@ -259,110 +329,46 @@ myclass.on("constructed", [] (int i) {
|
||||
|
||||
```
|
||||
|
||||
Implementing a class with multiple triggers of different types
|
||||
Asynchronous file IO
|
||||
|
||||
```c++
|
||||
string data_;
|
||||
|
||||
class ClassWithTriggers {
|
||||
Trigger<int> emitter1;
|
||||
Trigger<string> emitter2;
|
||||
|
||||
public:
|
||||
ClassWithTriggers(): emitter1(asynco_default_runtime()), emitter2(asynco_default_runtime()) {}
|
||||
|
||||
template<typename... T>
|
||||
void on(const string& key, function<void(T...)> callback) {
|
||||
if constexpr (sizeof...(T) == 1 && is_same_v<tuple_element_t<0, tuple<T...>>, int>) {
|
||||
emitter1.on(key, callback);
|
||||
}
|
||||
else if constexpr (sizeof...(T) == 1 && is_same_v<tuple_element_t<0, tuple<T...>>, string>) {
|
||||
emitter2.on(key, callback);
|
||||
}
|
||||
fs::read("test.txt", [&data_] (string data, exception* error) {
|
||||
if (error) {
|
||||
cout << "Error " << error->what() << endl;
|
||||
} else {
|
||||
cout << "Data " << endl << data << endl;
|
||||
data_ = data;
|
||||
cout << "Data_" << data_ << endl;
|
||||
}
|
||||
});
|
||||
|
||||
template <typename... Args>
|
||||
void tick(const string& key, Args&&... args) {
|
||||
if constexpr (sizeof...(Args) == 1 && is_same_v<tuple_element_t<0, tuple<Args...>>, int>) {
|
||||
emitter1.tick(key, forward<Args>(args)...);
|
||||
}
|
||||
else if constexpr (sizeof...(Args) == 1 && is_same_v<tuple_element_t<0, tuple<Args...>>, string>) {
|
||||
emitter2.tick(key, forward<Args>(args)...);
|
||||
}
|
||||
else {
|
||||
static_assert(sizeof...(Args) == 0, "Unsupported number or types of arguments");
|
||||
}
|
||||
fs::write("test1.txt", "Hello world", [] (exception* error) {
|
||||
if (error) {
|
||||
cout << "Error " << error->what() << endl;
|
||||
} else {
|
||||
cout << "Write successfuly" << endl;
|
||||
}
|
||||
};
|
||||
});
|
||||
|
||||
ClassWithTriggers mt;
|
||||
auto future_data = fs::read("test.txt");
|
||||
|
||||
mt.on<int>("int", function<void(int)>([&](int i) {
|
||||
cout << "Emit int " << i << endl;
|
||||
}));
|
||||
try {
|
||||
string data = await_(future_data);
|
||||
} catch (exception& err) {
|
||||
cout << err.what() << endl;
|
||||
}
|
||||
|
||||
mt.on<string>("string", function<void(string)>([&](string s) {
|
||||
cout << "Emit string " << s << endl;
|
||||
}));
|
||||
auto future_status = fs::write("test.txt", "Hello world");
|
||||
|
||||
mt.tick("int", 5);
|
||||
mt.tick("string", string("Hello world"));
|
||||
|
||||
```
|
||||
|
||||
## Coroutine
|
||||
|
||||
If `define.hpp` is included, you can initialize coroutines with `boost::asio::awaitable<T>`.
|
||||
|
||||
```c++
|
||||
|
||||
awaitable<int> c2(int a) {
|
||||
co_return a * 2;
|
||||
try {
|
||||
await_(future_status);
|
||||
} catch (exception& err) {
|
||||
cout << err.what() << endl;
|
||||
}
|
||||
|
||||
```
|
||||
To run the coroutine at runtime, simply call:
|
||||
```c++
|
||||
|
||||
async_(c2(4));
|
||||
|
||||
```
|
||||
Or using a lambda expression:
|
||||
|
||||
```c++
|
||||
|
||||
async_([]() -> awaitable<void> {
|
||||
std::cout << "Hello" << std::endl;
|
||||
co_await c2(4);
|
||||
co_return;
|
||||
}());
|
||||
|
||||
```
|
||||
To retrieve results from coroutines, you can do so as you would from classical functions by calling `await_`:
|
||||
```c++
|
||||
|
||||
int r = await_(
|
||||
async_(
|
||||
c2(10)
|
||||
));
|
||||
|
||||
```
|
||||
|
||||
If you need the result immediately, you can use a shorter notation
|
||||
|
||||
```c++
|
||||
|
||||
auto a = await_ ( c2(3));
|
||||
cout << a << endl;
|
||||
|
||||
await_ ([]() -> awaitable<void> {
|
||||
cout << "Hello" << endl;
|
||||
co_return;
|
||||
}());
|
||||
|
||||
```
|
||||
|
||||
If you need a result, you can also retrieve it with `await_`.
|
||||
Here too you can use your own runtime instance, only the methods are `.async()` and `.await()`
|
||||
|
||||
## License
|
||||
|
||||
|
||||
210
lib/asynco.hpp
210
lib/asynco.hpp
@ -1,187 +1,61 @@
|
||||
#ifndef _ASYNCO_
|
||||
#define _ASYNCO_
|
||||
|
||||
#include <vector>
|
||||
#include <memory>
|
||||
#include <type_traits>
|
||||
#include <thread>
|
||||
#include <future>
|
||||
#include <functional>
|
||||
#include "engine.hpp"
|
||||
#include <iostream>
|
||||
|
||||
using namespace std;
|
||||
|
||||
#include <boost/asio.hpp>
|
||||
#if __cplusplus >= 202002L
|
||||
#include <boost/asio/awaitable.hpp>
|
||||
#include <boost/asio/co_spawn.hpp>
|
||||
#include <boost/asio/use_awaitable.hpp>
|
||||
#endif
|
||||
using namespace boost::asio;
|
||||
|
||||
#include "timers.hpp"
|
||||
#include "trigger.hpp"
|
||||
|
||||
namespace marcelb {
|
||||
namespace asynco {
|
||||
|
||||
/**
|
||||
* Asynco runtime
|
||||
* Used for all asynchronous capabilities of this wrapper
|
||||
* Initializes threads and boost::asio::io_context
|
||||
* Run the function asynchronously
|
||||
*/
|
||||
class Asynco {
|
||||
vector<thread> _runners;
|
||||
unique_ptr<io_service::work> _work;
|
||||
template<class F, class... Args>
|
||||
auto async_(F&& f, Args&&... args) -> future<typename result_of<F(Args...)>::type> {
|
||||
using return_type = typename result_of<F(Args...)>::type;
|
||||
future<return_type> res = _asynco_engine.io_context.post(boost::asio::use_future(bind(forward<F>(f), forward<Args>(args)...)));
|
||||
return res;
|
||||
}
|
||||
|
||||
void init_loops_in_threads(uint8_t threads);
|
||||
/**
|
||||
* Block until the asynchronous call completes
|
||||
*/
|
||||
template<typename T>
|
||||
T await_(future<T>& r) {
|
||||
return r.get();
|
||||
}
|
||||
|
||||
public:
|
||||
io_context io_ctx;
|
||||
/**
|
||||
* Block until the asynchronous call completes
|
||||
*/
|
||||
template<typename T>
|
||||
T await_(future<T>&& r) {
|
||||
return move(r).get();
|
||||
}
|
||||
|
||||
/**
|
||||
* It starts the thread initialization and the Boost::Asio event loop in each of them
|
||||
*/
|
||||
|
||||
void run(uint8_t threads = thread::hardware_concurrency());
|
||||
|
||||
/**
|
||||
* Starts Boost::Asio event loop in the current thread
|
||||
*/
|
||||
|
||||
void run_on_this();
|
||||
|
||||
/**
|
||||
* Waits until all threads have finished working
|
||||
*/
|
||||
|
||||
void join();
|
||||
|
||||
/**
|
||||
* Run the function asynchronously in runtime
|
||||
*/
|
||||
template<class F, class... Args>
|
||||
auto async(F&& f, Args&&... args) -> future<invoke_result_t<F, Args...>> {
|
||||
using return_type = invoke_result_t<F, Args...>;
|
||||
future<return_type> res = io_ctx.post(boost::asio::use_future(bind(forward<F>(f), forward<Args>(args)...)));
|
||||
return res;
|
||||
/**
|
||||
* Block until the asynchronous call completes or time expired
|
||||
*/
|
||||
template<typename T>
|
||||
T await_(future<T>& r, uint64_t time) {
|
||||
if (r.wait_for(chrono::milliseconds(time)) == std::future_status::timeout) {
|
||||
throw runtime_error("Asynchronous execution timed out");
|
||||
}
|
||||
return r.get();
|
||||
}
|
||||
|
||||
#if __cplusplus >= 202002L
|
||||
/**
|
||||
* Run the coroutine in runtime
|
||||
*/
|
||||
template <typename T>
|
||||
future<T> async(boost::asio::awaitable<T> _coroutine) {
|
||||
promise<T> promise;
|
||||
auto future = promise.get_future();
|
||||
|
||||
co_spawn(io_ctx, [_coroutine = move(_coroutine), promise = move(promise)]() mutable -> boost::asio::awaitable<void> {
|
||||
try {
|
||||
if constexpr (!is_void_v<T>) {
|
||||
T result = co_await move(_coroutine);
|
||||
promise.set_value(move(result));
|
||||
} else {
|
||||
co_await move(_coroutine);
|
||||
promise.set_value(); // Za void ne postavljamo rezultat
|
||||
}
|
||||
} catch (...) {
|
||||
promise.set_exception(current_exception()); // Postavljamo izuzetak
|
||||
}
|
||||
}, boost::asio::detached);
|
||||
|
||||
return future;
|
||||
}
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Wait until the asynchronous call completes
|
||||
*/
|
||||
template<typename T>
|
||||
T await(future<T>& r, uint16_t time_us = 10) {
|
||||
while (r.wait_for(std::chrono::microseconds(time_us)) != future_status::ready) {
|
||||
io_ctx.poll_one();
|
||||
}
|
||||
return r.get();
|
||||
}
|
||||
|
||||
/**
|
||||
* Wait until the asynchronous call completes
|
||||
*/
|
||||
template<typename T>
|
||||
T await(future<T>&& r, uint16_t time_us = 10) {
|
||||
while (r.wait_for(std::chrono::microseconds(time_us)) != future_status::ready) {
|
||||
io_ctx.poll_one();
|
||||
}
|
||||
return move(r).get();
|
||||
}
|
||||
|
||||
/**
|
||||
* Run the function asynchronously an wait until completes
|
||||
*/
|
||||
template<class F, class... Args>
|
||||
auto await(F&& f, Args&&... args) -> invoke_result_t<F, Args...> {
|
||||
return await(
|
||||
async(f, args...)
|
||||
);
|
||||
}
|
||||
|
||||
#if __cplusplus >= 202002L
|
||||
/**
|
||||
* Run the coruotine and wait
|
||||
*/
|
||||
template <typename T>
|
||||
T await(boost::asio::awaitable<T> _coroutine) {
|
||||
return await(
|
||||
async(
|
||||
move(_coroutine)
|
||||
));
|
||||
}
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Wait until the multiple asynchronous call completes
|
||||
* Use only on no-void calls
|
||||
*/
|
||||
|
||||
template<typename... F>
|
||||
auto await(F&&... f) -> tuple<typename decay<decltype(await(f))>::type...> {
|
||||
return make_tuple(await(f)...);
|
||||
}
|
||||
|
||||
/**
|
||||
* Wait until the multiple asynchronous call completes
|
||||
* Use only on no-void calls
|
||||
*/
|
||||
|
||||
template<typename... F>
|
||||
auto await(F&... f) -> tuple<typename decay<decltype(await(f))>::type...> {
|
||||
return make_tuple(await(f)...);
|
||||
}
|
||||
|
||||
/**
|
||||
* Initialize the delayed timer
|
||||
*/
|
||||
|
||||
Timer delayed(function<void()> callback, uint64_t time);
|
||||
|
||||
/**
|
||||
* Initialize the periodic timer
|
||||
*/
|
||||
|
||||
Timer periodic(function<void()> callback, uint64_t time);
|
||||
|
||||
/**
|
||||
* Initialize trigger (typed event)
|
||||
*/
|
||||
|
||||
template<typename... T>
|
||||
Trigger<T...> trigger() {
|
||||
return Trigger<T...>(*this);
|
||||
}
|
||||
|
||||
|
||||
};
|
||||
|
||||
/**
|
||||
* Block until the asynchronous call completes or time expired
|
||||
*/
|
||||
template<typename T>
|
||||
T await_(future<T>&& r, uint64_t time) {
|
||||
if (r.wait_for(chrono::milliseconds(time)) == std::future_status::timeout) {
|
||||
throw runtime_error("Asynchronous execution timed out");
|
||||
}
|
||||
return move(r).get();
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,155 +0,0 @@
|
||||
#ifndef _ASYNCO_DEFAULT_
|
||||
#define _ASYNCO_DEFAULT_
|
||||
|
||||
#include "asynco.hpp"
|
||||
|
||||
namespace marcelb {
|
||||
namespace asynco {
|
||||
|
||||
/**
|
||||
* Default runtime
|
||||
*/
|
||||
|
||||
extern Asynco Asynco_Default_Runtime;
|
||||
|
||||
/**
|
||||
* Run the function asynchronously in default runtime
|
||||
*/
|
||||
template<class F, class... Args>
|
||||
auto async_(F&& f, Args&&... args) -> future<invoke_result_t<F, Args...>> {
|
||||
return Asynco_Default_Runtime.async(bind(forward<F>(f), forward<Args>(args)...));
|
||||
}
|
||||
|
||||
#if __cplusplus >= 202002L
|
||||
/**
|
||||
* Run the coroutine in default runtime
|
||||
*/
|
||||
template <typename T>
|
||||
std::future<T> async_(boost::asio::awaitable<T> _coroutine) {
|
||||
return Asynco_Default_Runtime.async(move(_coroutine));
|
||||
}
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Wait until the asynchronous call completes
|
||||
*/
|
||||
template<typename T>
|
||||
T await_(future<T>& r, uint16_t time_us = 10) {
|
||||
return Asynco_Default_Runtime.await(r, time_us);
|
||||
}
|
||||
|
||||
/**
|
||||
* Wait until the asynchronous call completes
|
||||
*/
|
||||
template<typename T>
|
||||
T await_(future<T>&& r, uint16_t time_us = 10) {
|
||||
return Asynco_Default_Runtime.await(r, time_us);
|
||||
}
|
||||
|
||||
/**
|
||||
* Run the function asynchronously an wait until completes
|
||||
*/
|
||||
template<class F, class... Args>
|
||||
auto await_(F&& f, Args&&... args) -> invoke_result_t<F, Args...> {
|
||||
return Asynco_Default_Runtime.await(bind(forward<F>(f), forward<Args>(args)...));
|
||||
}
|
||||
|
||||
|
||||
#if __cplusplus >= 202002L
|
||||
/**
|
||||
* Run the coruotine and wait
|
||||
*/
|
||||
template <typename T>
|
||||
T await_(boost::asio::awaitable<T> _coroutine) {
|
||||
return Asynco_Default_Runtime.await(move(_coroutine));
|
||||
}
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Wait until the multiple asynchronous call completes
|
||||
* Use only on no-void calls
|
||||
*/
|
||||
|
||||
template<typename... F>
|
||||
auto await_(F&&... f) -> std::tuple<typename std::decay<decltype(Asynco_Default_Runtime.await(f))>::type...> {
|
||||
return Asynco_Default_Runtime.await(move(f)...);
|
||||
}
|
||||
|
||||
/**
|
||||
* Wait until the multiple asynchronous call completes
|
||||
* Use only on no-void calls
|
||||
*/
|
||||
|
||||
template<typename... F>
|
||||
auto await_(F&... f) -> std::tuple<typename std::decay<decltype(Asynco_Default_Runtime.await(f))>::type...> {
|
||||
return Asynco_Default_Runtime.await(f...);;
|
||||
}
|
||||
|
||||
/**
|
||||
* Initialize the delayed timer
|
||||
*/
|
||||
|
||||
Timer delayed(function<void()> callback, uint64_t time);
|
||||
|
||||
/**
|
||||
* Initialize the periodic timer
|
||||
*/
|
||||
|
||||
Timer periodic(function<void()> callback, uint64_t time);
|
||||
|
||||
/**
|
||||
* Initialize trigger (typed event)
|
||||
*/
|
||||
|
||||
template<typename... T>
|
||||
Trigger<T...> trigger() {
|
||||
return Trigger<T...>(Asynco_Default_Runtime);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get reference of default runtime
|
||||
*/
|
||||
|
||||
Asynco& asynco_default_runtime();
|
||||
|
||||
/**
|
||||
* Run default runtime
|
||||
*/
|
||||
|
||||
void asynco_default_run();
|
||||
|
||||
/**
|
||||
* Run default runtime in this thread
|
||||
*/
|
||||
|
||||
void asynco_default_run_on_this();
|
||||
|
||||
/**
|
||||
* Waits until all threads have finished working
|
||||
*/
|
||||
|
||||
void asynco_default_join();
|
||||
|
||||
/**
|
||||
* Get reference of boost::asio::io_context
|
||||
*/
|
||||
|
||||
io_context& asynco_default_io_context();
|
||||
|
||||
/**
|
||||
* Run the function asynchronously in default runtime
|
||||
*/
|
||||
#define async_ marcelb::asynco::async_
|
||||
|
||||
/**
|
||||
* Wait until the asynchronous call completes
|
||||
*/
|
||||
#define await_ marcelb::asynco::await_
|
||||
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
19
lib/define.hpp
Normal file
19
lib/define.hpp
Normal file
@ -0,0 +1,19 @@
|
||||
#ifndef _ASYNCO_DEFINE_
|
||||
#define _ASYNCO_DEFINE_
|
||||
|
||||
namespace marcelb {
|
||||
namespace asynco {
|
||||
|
||||
/**
|
||||
* Alternative names of functions - mostly for the sake of more beautiful coloring of the code
|
||||
*/
|
||||
|
||||
#define async_ marcelb::asynco::async_
|
||||
#define await_ marcelb::asynco::await_
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
71
lib/engine.hpp
Normal file
71
lib/engine.hpp
Normal file
@ -0,0 +1,71 @@
|
||||
#ifndef _ASYNCO_ENGINE_
|
||||
#define _ASYNCO_ENGINE_
|
||||
|
||||
#include <vector>
|
||||
#include <memory>
|
||||
using namespace std;
|
||||
|
||||
#include <boost/asio.hpp>
|
||||
|
||||
namespace marcelb {
|
||||
namespace asynco {
|
||||
|
||||
#define HW_CONCURRENCY_MINIMAL 4
|
||||
|
||||
/**
|
||||
* Internal anonymous class for initializing the ASIO context and thread pool
|
||||
* !!! It is anonymous to protect against use in the initialization of other objects of the same type !!!
|
||||
*/
|
||||
class Engine {
|
||||
public:
|
||||
boost::asio::io_context io_context;
|
||||
|
||||
void run() {
|
||||
for (auto& runner : runners) {
|
||||
runner.join();
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
unique_ptr<boost::asio::io_service::work> work { [&] () {
|
||||
return new boost::asio::io_service::work(io_context);
|
||||
} ()};
|
||||
|
||||
vector<thread> runners { [&] () {
|
||||
vector<thread> _runs;
|
||||
unsigned int num_of_runners;
|
||||
#ifdef NUM_OF_RUNNERS
|
||||
num_of_runners = NUM_OF_RUNNERS;
|
||||
#else
|
||||
num_of_runners = thread::hardware_concurrency();
|
||||
if (num_of_runners < HW_CONCURRENCY_MINIMAL) {
|
||||
num_of_runners = HW_CONCURRENCY_MINIMAL;
|
||||
}
|
||||
#endif
|
||||
|
||||
for (int i=0; i<num_of_runners; i++) {
|
||||
_runs.push_back(thread ( [this] () {
|
||||
io_context.run();
|
||||
}));
|
||||
}
|
||||
|
||||
return _runs;
|
||||
} ()};
|
||||
|
||||
};
|
||||
|
||||
|
||||
extern Engine _asynco_engine;
|
||||
|
||||
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
115
lib/filesystem.hpp
Normal file
115
lib/filesystem.hpp
Normal file
@ -0,0 +1,115 @@
|
||||
#ifndef _ASYNCO_FS_
|
||||
#define _ASYNCO_FS_
|
||||
|
||||
#include "asynco.hpp"
|
||||
|
||||
using namespace marcelb;
|
||||
using namespace asynco;
|
||||
|
||||
#include <fstream>
|
||||
using namespace std;
|
||||
|
||||
|
||||
namespace marcelb {
|
||||
namespace asynco {
|
||||
namespace fs {
|
||||
|
||||
/**
|
||||
* Asynchronous file reading with callback after read complete
|
||||
*/
|
||||
template<typename Callback>
|
||||
void read(string path, Callback&& callback) {
|
||||
asynco::async_( [&path, callback] () {
|
||||
string content;
|
||||
try {
|
||||
string line;
|
||||
ifstream file (path);
|
||||
if (file.is_open()) {
|
||||
line.clear();
|
||||
while ( getline (file,line) ) {
|
||||
content += line + "\n";
|
||||
}
|
||||
file.close();
|
||||
}
|
||||
|
||||
else {
|
||||
throw runtime_error("Unable to open file");
|
||||
}
|
||||
|
||||
callback(content, nullptr);
|
||||
} catch(exception& error) {
|
||||
callback(content, &error);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Asynchronous file reading
|
||||
*/
|
||||
future<string> read(string path) {
|
||||
return asynco::async_( [&path] () {
|
||||
string content;
|
||||
string line;
|
||||
ifstream file (path);
|
||||
if (file.is_open()) {
|
||||
line.clear();
|
||||
while ( getline (file,line) ) {
|
||||
content += line + "\n";
|
||||
}
|
||||
file.close();
|
||||
return content;
|
||||
}
|
||||
|
||||
else {
|
||||
throw runtime_error("Unable to open file");
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Asynchronous file writing with callback after write complete
|
||||
*/
|
||||
template<typename Callback>
|
||||
void write(string path, string content, Callback&& callback) {
|
||||
asynco::async_( [&path, &content, callback] () {
|
||||
try {
|
||||
ofstream file (path);
|
||||
if (file.is_open()) {
|
||||
file << content;
|
||||
file.close();
|
||||
}
|
||||
else {
|
||||
throw runtime_error("Unable to open file");
|
||||
}
|
||||
|
||||
callback(nullptr);
|
||||
} catch(exception& error) {
|
||||
callback(&error);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Asynchronous file writing with callback after write complete
|
||||
*/
|
||||
future<void> write(string path, string content) {
|
||||
return asynco::async_( [&path, &content] () {
|
||||
ofstream file (path);
|
||||
if (file.is_open()) {
|
||||
file << content;
|
||||
file.close();
|
||||
return;
|
||||
}
|
||||
else {
|
||||
throw runtime_error("Unable to open file");
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
108
lib/timers.hpp
108
lib/timers.hpp
@ -2,11 +2,9 @@
|
||||
#define _ASYNCO_TIMERS_
|
||||
|
||||
#include <chrono>
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
|
||||
#include <boost/asio.hpp>
|
||||
using namespace boost::asio;
|
||||
#include "asynco.hpp"
|
||||
|
||||
namespace marcelb {
|
||||
namespace asynco {
|
||||
@ -23,19 +21,13 @@ int64_t rtime_ms();
|
||||
|
||||
int64_t rtime_us();
|
||||
|
||||
enum TimerType {
|
||||
Delayed,
|
||||
Periodic
|
||||
};
|
||||
|
||||
/**
|
||||
* Core timer class for construct time async functions
|
||||
*/
|
||||
class Timer {
|
||||
io_context& io_ctx;
|
||||
steady_timer st;
|
||||
class timer {
|
||||
boost::asio::steady_timer st;
|
||||
bool _stop = false;
|
||||
TimerType type;
|
||||
bool repeate;
|
||||
function<void()> callback;
|
||||
uint64_t time;
|
||||
uint64_t _ticks = 0;
|
||||
@ -43,13 +35,14 @@ class Timer {
|
||||
/**
|
||||
* A method to assign a callback wrapper and a reinitialization algorithm
|
||||
*/
|
||||
void init();
|
||||
void init();
|
||||
|
||||
public:
|
||||
|
||||
/**
|
||||
* The constructor creates the steady_timer and accompanying variables and runs a method to initialize the timer
|
||||
*/
|
||||
Timer (io_context& io_ctx, function<void()> _callback, uint64_t _time, TimerType _type = TimerType::Delayed);
|
||||
timer (function<void()> _callback, uint64_t _time, bool _repeate);
|
||||
|
||||
/**
|
||||
* Stop timer
|
||||
@ -69,21 +62,98 @@ class Timer {
|
||||
uint64_t ticks();
|
||||
|
||||
/**
|
||||
* Get is the delayed callback runned
|
||||
* The logic status of the timer stop state
|
||||
*/
|
||||
bool expired();
|
||||
bool stoped();
|
||||
/**
|
||||
* The destructor stops the timer
|
||||
*/
|
||||
~timer();
|
||||
};
|
||||
|
||||
/**
|
||||
* Class periodic for periodic execution of the callback in time in ms
|
||||
*/
|
||||
class periodic {
|
||||
shared_ptr<timer> _timer;
|
||||
|
||||
public:
|
||||
|
||||
/**
|
||||
* The logic status of the timer stop state
|
||||
* Constructor initializes a shared pointer of type timer
|
||||
*/
|
||||
periodic(function<void()> callback, uint64_t time);
|
||||
|
||||
/**
|
||||
* Stop periodic
|
||||
* The stop flag is set and periodic remove it from the queue
|
||||
*/
|
||||
void stop();
|
||||
|
||||
/**
|
||||
* Run callback now
|
||||
* Forces the callback function to run independently of the periodic
|
||||
*/
|
||||
void now();
|
||||
|
||||
/**
|
||||
* Get the number of times the periodic callback was runned
|
||||
*/
|
||||
uint64_t ticks();
|
||||
/**
|
||||
* The logic status of the periodic stop state
|
||||
*/
|
||||
bool stoped();
|
||||
|
||||
/**
|
||||
* The destructor stops the timer
|
||||
* The destructor stops the periodic
|
||||
*/
|
||||
~Timer();
|
||||
~periodic();
|
||||
};
|
||||
|
||||
/**
|
||||
* Class delayed for delayed callback execution in ms
|
||||
*/
|
||||
class delayed {
|
||||
shared_ptr<timer> _timer;
|
||||
|
||||
public:
|
||||
|
||||
/**
|
||||
* Constructor initializes a shared pointer of type timer
|
||||
*/
|
||||
delayed(function<void()> callback, uint64_t time);
|
||||
|
||||
/**
|
||||
* Stop delayed
|
||||
* The stop flag is set and delayed remove it from the queue
|
||||
*/
|
||||
void stop();
|
||||
|
||||
/**
|
||||
* Run callback now
|
||||
* Forces the callback function to run independently of the delayed
|
||||
*/
|
||||
void now();
|
||||
|
||||
/**
|
||||
* Get is the delayed callback runned
|
||||
*/
|
||||
bool expired();
|
||||
/**
|
||||
* The logic status of the delayed stop state
|
||||
*/
|
||||
bool stoped();
|
||||
/**
|
||||
* The destructor stops the delayed
|
||||
*/
|
||||
~delayed();
|
||||
|
||||
};
|
||||
|
||||
shared_ptr<periodic> Periodic(function<void()> callback, uint64_t time);
|
||||
shared_ptr<delayed> Delayed(function<void()> callback, uint64_t time);
|
||||
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
@ -8,26 +8,22 @@
|
||||
|
||||
using namespace std;
|
||||
|
||||
#include "asynco.hpp"
|
||||
#include "engine.hpp"
|
||||
namespace marcelb {
|
||||
namespace asynco {
|
||||
|
||||
class Asynco;
|
||||
namespace triggers {
|
||||
|
||||
/**
|
||||
* Trigger class, for event-driven programming.
|
||||
* trigger class, for event-driven programming.
|
||||
* These events are typed according to the arguments of the callback function
|
||||
*/
|
||||
template<typename... T>
|
||||
class Trigger {
|
||||
class trigger {
|
||||
private:
|
||||
Asynco& engine;
|
||||
mutex m_eve;
|
||||
unordered_map<string, vector<function<void(T...)>>> triggers;
|
||||
|
||||
public:
|
||||
Trigger(Asynco& _engine)
|
||||
: engine(_engine) {}
|
||||
|
||||
/**
|
||||
* Defines event by key, and callback function
|
||||
@ -37,7 +33,6 @@ class Trigger {
|
||||
triggers[key].push_back(callback);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* It emits an event and sends a callback function saved according to the key with the passed parameters
|
||||
*/
|
||||
@ -47,29 +42,30 @@ class Trigger {
|
||||
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)...);
|
||||
engine.async(callback);
|
||||
asynco::async_(callback);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove an Trigger listener from an event
|
||||
* Remove an trigger listener from an event
|
||||
*/
|
||||
void off(const string& key) {
|
||||
void off(const string& key) {
|
||||
lock_guard _off(m_eve);
|
||||
triggers.erase(key);
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove all Trigger listener
|
||||
* Remove all trigger listener
|
||||
*/
|
||||
void off() {
|
||||
lock_guard _off(m_eve);
|
||||
triggers.clear();
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Get num of listeners by an Trigger key
|
||||
* Get num of listeners by an trigger key
|
||||
*/
|
||||
unsigned int listeners(const string& key) {
|
||||
return triggers[key].size();
|
||||
@ -89,6 +85,7 @@ class Trigger {
|
||||
|
||||
};
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -1,41 +0,0 @@
|
||||
#include "../lib/asynco.hpp"
|
||||
|
||||
namespace marcelb::asynco {
|
||||
|
||||
|
||||
void Asynco::init_loops_in_threads(uint8_t threads) {
|
||||
for (int i=0; i<threads; i++) {
|
||||
_runners.push_back(thread ( [this] () {
|
||||
io_ctx.run();
|
||||
}));
|
||||
}
|
||||
}
|
||||
|
||||
void Asynco::run(uint8_t threads) {
|
||||
_work = make_unique<io_service::work>(io_ctx);
|
||||
init_loops_in_threads(threads);
|
||||
}
|
||||
|
||||
void Asynco::run_on_this() {
|
||||
if (!_work) {
|
||||
_work = make_unique<io_service::work>(io_ctx);
|
||||
}
|
||||
io_ctx.run();
|
||||
}
|
||||
|
||||
void Asynco::join() {
|
||||
for (auto& runner : _runners) {
|
||||
runner.join();
|
||||
}
|
||||
}
|
||||
|
||||
Timer Asynco::delayed(function<void()> callback, uint64_t time) {
|
||||
return Timer(io_ctx, callback, time, TimerType::Delayed);
|
||||
}
|
||||
|
||||
Timer Asynco::periodic(function<void()> callback, uint64_t time) {
|
||||
return Timer(io_ctx, callback, time, TimerType::Periodic);
|
||||
}
|
||||
|
||||
|
||||
};
|
||||
@ -1,36 +0,0 @@
|
||||
|
||||
#include "../lib/asynco_default.hpp"
|
||||
|
||||
namespace marcelb::asynco {
|
||||
|
||||
Asynco Asynco_Default_Runtime;
|
||||
|
||||
Timer delayed(function<void()> callback, uint64_t time) {
|
||||
return Timer(Asynco_Default_Runtime.io_ctx, callback, time, TimerType::Delayed);
|
||||
}
|
||||
|
||||
Timer periodic(function<void()> callback, uint64_t time) {
|
||||
return Timer(Asynco_Default_Runtime.io_ctx, callback, time, TimerType::Periodic);
|
||||
}
|
||||
|
||||
Asynco& asynco_default_runtime() {
|
||||
return Asynco_Default_Runtime;
|
||||
}
|
||||
|
||||
void asynco_default_run() {
|
||||
Asynco_Default_Runtime.run();
|
||||
}
|
||||
|
||||
void asynco_default_run_on_this() {
|
||||
Asynco_Default_Runtime.run_on_this();
|
||||
}
|
||||
|
||||
void asynco_default_join() {
|
||||
Asynco_Default_Runtime.join();
|
||||
}
|
||||
|
||||
io_context& asynco_default_io_context() {
|
||||
return Asynco_Default_Runtime.io_ctx;
|
||||
}
|
||||
|
||||
};
|
||||
7
src/engine.cpp
Normal file
7
src/engine.cpp
Normal file
@ -0,0 +1,7 @@
|
||||
#include "../lib/engine.hpp"
|
||||
|
||||
namespace marcelb::asynco {
|
||||
|
||||
Engine _asynco_engine;
|
||||
|
||||
};
|
||||
116
src/timers.cpp
116
src/timers.cpp
@ -3,23 +3,23 @@
|
||||
namespace marcelb::asynco {
|
||||
|
||||
int64_t rtime_ms() {
|
||||
return std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now()
|
||||
return chrono::duration_cast<chrono::milliseconds>(chrono::system_clock::now()
|
||||
.time_since_epoch())
|
||||
.count();
|
||||
}
|
||||
|
||||
int64_t rtime_us() {
|
||||
return std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::system_clock::now()
|
||||
return chrono::duration_cast<chrono::microseconds>(chrono::system_clock::now()
|
||||
.time_since_epoch())
|
||||
.count();
|
||||
}
|
||||
|
||||
void Timer::init() {
|
||||
void timer::init() {
|
||||
st.async_wait( [this] (const boost::system::error_code&) {
|
||||
if (!_stop) {
|
||||
callback();
|
||||
if (type == TimerType::Periodic) {
|
||||
st = steady_timer(io_ctx, boost::asio::chrono::milliseconds(time));
|
||||
if (repeate) {
|
||||
st = boost::asio::steady_timer(_asynco_engine.io_context, boost::asio::chrono::milliseconds(time));
|
||||
init();
|
||||
}
|
||||
_ticks++;
|
||||
@ -27,39 +27,119 @@ void Timer::init() {
|
||||
});
|
||||
}
|
||||
|
||||
Timer::Timer (io_context& _io_ctx, function<void()> _callback, uint64_t _time, TimerType _type):
|
||||
io_ctx(_io_ctx),
|
||||
st(io_ctx, boost::asio::chrono::milliseconds(_time)),
|
||||
timer::timer (function<void()> _callback, uint64_t _time, bool _repeate) :
|
||||
st(_asynco_engine.io_context, boost::asio::chrono::milliseconds(_time)),
|
||||
_stop(false),
|
||||
type(_type),
|
||||
repeate(_repeate),
|
||||
callback(_callback),
|
||||
time(_time) {
|
||||
|
||||
init();
|
||||
}
|
||||
|
||||
void Timer::stop() {
|
||||
void timer::stop() {
|
||||
_stop = true;
|
||||
st.cancel();
|
||||
}
|
||||
|
||||
void Timer::now() {
|
||||
void timer::now() {
|
||||
st.cancel();
|
||||
}
|
||||
|
||||
uint64_t Timer::ticks() {
|
||||
uint64_t timer::ticks() {
|
||||
return _ticks;
|
||||
}
|
||||
|
||||
bool Timer::expired() {
|
||||
return bool(_ticks);
|
||||
}
|
||||
|
||||
bool Timer::stoped() {
|
||||
bool timer::stoped() {
|
||||
return _stop;
|
||||
}
|
||||
|
||||
Timer::~Timer() {
|
||||
timer::~timer() {
|
||||
stop();
|
||||
}
|
||||
|
||||
periodic::periodic(function<void()> callback, uint64_t time) :
|
||||
_timer(make_shared<timer> (callback, time, true)) {
|
||||
}
|
||||
|
||||
void periodic::stop() {
|
||||
_timer->stop();
|
||||
}
|
||||
|
||||
void periodic::now() {
|
||||
_timer->now();
|
||||
}
|
||||
|
||||
uint64_t periodic::ticks() {
|
||||
return _timer->ticks();
|
||||
}
|
||||
|
||||
bool periodic::stoped() {
|
||||
return _timer->stoped();
|
||||
}
|
||||
|
||||
periodic::~periodic() {
|
||||
stop();
|
||||
}
|
||||
|
||||
delayed::delayed(function<void()> callback, uint64_t time) :
|
||||
_timer(make_shared<timer> (callback, time, false)) {
|
||||
}
|
||||
|
||||
void delayed::stop() {
|
||||
_timer->stop();
|
||||
}
|
||||
|
||||
void delayed::now() {
|
||||
_timer->now();
|
||||
}
|
||||
|
||||
bool delayed::expired() {
|
||||
return bool(_timer->ticks());
|
||||
}
|
||||
|
||||
bool delayed::stoped() {
|
||||
return _timer->stoped();
|
||||
}
|
||||
|
||||
delayed::~delayed() {
|
||||
stop();
|
||||
}
|
||||
|
||||
mutex p_io, d_io;
|
||||
vector<shared_ptr<periodic>> periodic_calls_container;
|
||||
vector<shared_ptr<delayed>> delayed_calls_container;
|
||||
|
||||
shared_ptr<periodic> Periodic(function<void()> callback, uint64_t time) {
|
||||
shared_ptr<periodic> periodic_ptr(make_shared<periodic>(callback, time));
|
||||
async_ ( [&, periodic_ptr](){
|
||||
lock_guard<mutex> lock(p_io);
|
||||
periodic_calls_container.push_back(periodic_ptr);
|
||||
for (uint32_t i=0; i<periodic_calls_container.size(); i++) {
|
||||
if (periodic_calls_container[i]->stoped()) {
|
||||
periodic_calls_container.erase(periodic_calls_container.begin()+i);
|
||||
i--;
|
||||
}
|
||||
}
|
||||
});
|
||||
return periodic_ptr;
|
||||
}
|
||||
|
||||
shared_ptr<delayed> Delayed(function<void()> callback, uint64_t time) {
|
||||
shared_ptr<delayed> delayed_ptr(make_shared<delayed>(callback, time));
|
||||
async_ ( [&, delayed_ptr](){
|
||||
lock_guard<mutex> lock(p_io);
|
||||
delayed_calls_container.push_back(delayed_ptr);
|
||||
for (uint32_t i=0; i<delayed_calls_container.size(); i++) {
|
||||
if (delayed_calls_container[i]->stoped() || delayed_calls_container[i]->expired()) {
|
||||
delayed_calls_container.erase(delayed_calls_container.begin()+i);
|
||||
i--;
|
||||
}
|
||||
}
|
||||
});
|
||||
return delayed_ptr;
|
||||
}
|
||||
|
||||
|
||||
|
||||
};
|
||||
|
||||
@ -1,29 +0,0 @@
|
||||
add_executable(asynco_default main_default.cpp)
|
||||
target_link_libraries(asynco_default asynco Boost::system)
|
||||
|
||||
add_executable(asynco_init main_init.cpp)
|
||||
target_link_libraries(asynco_init asynco Boost::system)
|
||||
|
||||
add_executable(asynco_async_default main_async_default.cpp)
|
||||
target_link_libraries(asynco_async_default asynco Boost::system)
|
||||
|
||||
add_executable(asynco_async main_async.cpp)
|
||||
target_link_libraries(asynco_async asynco Boost::system)
|
||||
|
||||
add_executable(asynco_timers_default main_timers_default.cpp)
|
||||
target_link_libraries(asynco_timers_default asynco Boost::system)
|
||||
|
||||
add_executable(asynco_timers main_timers.cpp)
|
||||
target_link_libraries(asynco_timers asynco Boost::system)
|
||||
|
||||
add_executable(asynco_trigger_default main_trigger_default.cpp)
|
||||
target_link_libraries(asynco_trigger_default asynco Boost::system)
|
||||
|
||||
add_executable(asynco_trigger main_trigger.cpp)
|
||||
target_link_libraries(asynco_trigger asynco Boost::system)
|
||||
|
||||
add_executable(asynco_coroutine_default main_coroutine_default.cpp)
|
||||
target_link_libraries(asynco_coroutine_default asynco Boost::system)
|
||||
|
||||
add_executable(asynco_coroutine main_coroutine.cpp)
|
||||
target_link_libraries(asynco_coroutine asynco Boost::system)
|
||||
1
test/compile.sh
Normal file
1
test/compile.sh
Normal file
@ -0,0 +1 @@
|
||||
g++ test.cpp ../src/* -o test
|
||||
@ -1,84 +0,0 @@
|
||||
#include "../lib/asynco.hpp"
|
||||
using namespace marcelb::asynco;
|
||||
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
|
||||
Asynco asynco;
|
||||
|
||||
void notLambdaFunction() {
|
||||
cout << "Call to not lambda function" << endl;
|
||||
}
|
||||
|
||||
|
||||
class clm {
|
||||
public:
|
||||
void classMethode() {
|
||||
cout << "Call class method" << endl;
|
||||
}
|
||||
};
|
||||
|
||||
void sleep_to (int _time) {
|
||||
promise<void> _promise;
|
||||
Timer t = asynco.delayed( [&]() {
|
||||
_promise.set_value();
|
||||
}, _time);
|
||||
|
||||
return asynco.await(_promise.get_future());
|
||||
}
|
||||
|
||||
int main() {
|
||||
|
||||
asynco.run(2);
|
||||
|
||||
/**
|
||||
* Run an lambda function asynchronously
|
||||
*/
|
||||
|
||||
asynco.async ( []() {
|
||||
cout << "async " << endl;
|
||||
});
|
||||
|
||||
|
||||
/**
|
||||
* Run not lambda function
|
||||
*/
|
||||
|
||||
asynco.async (notLambdaFunction);
|
||||
|
||||
/**
|
||||
* Run class method
|
||||
*/
|
||||
|
||||
clm classes;
|
||||
asynco.async ( [&classes] () {
|
||||
classes.classMethode();
|
||||
});
|
||||
|
||||
//------------------AWAIT----------------------
|
||||
|
||||
auto a = asynco.async ( []() {
|
||||
sleep_to(1000); //only for simulating long duration function
|
||||
return 5;
|
||||
});
|
||||
|
||||
cout << asynco.await(a) << endl;
|
||||
|
||||
/**
|
||||
* await async function call and use i cout
|
||||
*/
|
||||
|
||||
cout << asynco.await(asynco.async ( [] () {
|
||||
sleep_to(1000);
|
||||
cout << "await_ end" << endl;
|
||||
return 4;
|
||||
})) << endl;
|
||||
|
||||
|
||||
asynco.await ([]() { // run in runtime and await now
|
||||
cout << "Hello" << endl;
|
||||
});
|
||||
|
||||
asynco.join();
|
||||
return 0;
|
||||
}
|
||||
@ -1,82 +0,0 @@
|
||||
#include "../lib/asynco_default.hpp"
|
||||
using namespace marcelb::asynco;
|
||||
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
|
||||
void notLambdaFunction() {
|
||||
cout << "Call to not lambda function" << endl;
|
||||
}
|
||||
|
||||
|
||||
class clm {
|
||||
public:
|
||||
void classMethode() {
|
||||
cout << "Call class method" << endl;
|
||||
}
|
||||
};
|
||||
|
||||
void sleep_to (int _time) {
|
||||
promise<void> _promise;
|
||||
Timer t = delayed( [&]() {
|
||||
_promise.set_value();
|
||||
}, _time);
|
||||
|
||||
return await_(_promise.get_future());
|
||||
}
|
||||
|
||||
int main() {
|
||||
|
||||
asynco_default_run();
|
||||
|
||||
/**
|
||||
* Run an lambda function asynchronously
|
||||
*/
|
||||
|
||||
async_ ( []() {
|
||||
cout << "async " << endl;
|
||||
});
|
||||
|
||||
|
||||
/**
|
||||
* Run not lambda function
|
||||
*/
|
||||
|
||||
async_ (notLambdaFunction);
|
||||
|
||||
/**
|
||||
* Run class method
|
||||
*/
|
||||
|
||||
clm classes;
|
||||
async_ ( [&classes] () {
|
||||
classes.classMethode();
|
||||
});
|
||||
|
||||
//------------------AWAIT----------------------
|
||||
|
||||
auto a = async_ ( []() {
|
||||
sleep_to(1000); //only for simulating long duration function
|
||||
return 5;
|
||||
});
|
||||
|
||||
cout << await_(a) << endl;
|
||||
|
||||
/**
|
||||
* await async function call and use i cout
|
||||
*/
|
||||
|
||||
cout << await_(async_ ( [] () {
|
||||
sleep_to(1000);
|
||||
cout << "await_ end" << endl;
|
||||
return 4;
|
||||
})) << endl;
|
||||
|
||||
|
||||
await_ ([]() { // run in runtime and await now
|
||||
cout << "Hello" << endl;
|
||||
});
|
||||
|
||||
asynco_default_join();
|
||||
return 0;
|
||||
}
|
||||
@ -1,43 +0,0 @@
|
||||
#include "../lib/asynco.hpp"
|
||||
using namespace marcelb::asynco;
|
||||
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
|
||||
awaitable<int> c2(int a) {
|
||||
co_return a * 2;
|
||||
}
|
||||
|
||||
|
||||
int main() {
|
||||
|
||||
Asynco asynco; // or global
|
||||
asynco.run(2);
|
||||
|
||||
asynco.async(c2(4));
|
||||
|
||||
asynco.async([]() -> awaitable<void> {
|
||||
std::cout << "Hello" << std::endl;
|
||||
co_await c2(4);
|
||||
co_return;
|
||||
}());
|
||||
|
||||
|
||||
int r = asynco.await(
|
||||
asynco.async(
|
||||
c2(10)
|
||||
));
|
||||
|
||||
|
||||
auto a = asynco.await( c2(3));
|
||||
cout << a << endl;
|
||||
|
||||
asynco.await([]() -> awaitable<void> {
|
||||
cout << "Hello" << endl;
|
||||
co_return;
|
||||
}());
|
||||
|
||||
|
||||
asynco.join();
|
||||
return 0;
|
||||
}
|
||||
@ -1,41 +0,0 @@
|
||||
#include "../lib/asynco_default.hpp"
|
||||
using namespace marcelb::asynco;
|
||||
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
|
||||
awaitable<int> c2(int a) {
|
||||
co_return a * 2;
|
||||
}
|
||||
|
||||
int main() {
|
||||
asynco_default_run();
|
||||
|
||||
|
||||
async_(c2(4));
|
||||
|
||||
async_([]() -> awaitable<void> {
|
||||
std::cout << "Hello" << std::endl;
|
||||
co_await c2(4);
|
||||
co_return;
|
||||
}());
|
||||
|
||||
|
||||
int r = await_(
|
||||
async_(
|
||||
c2(10)
|
||||
));
|
||||
|
||||
|
||||
auto a = await_ ( c2(3));
|
||||
cout << a << endl;
|
||||
|
||||
await_ ([]() -> awaitable<void> {
|
||||
cout << "Hello" << endl;
|
||||
co_return;
|
||||
}());
|
||||
|
||||
|
||||
asynco_default_join();
|
||||
return 0;
|
||||
}
|
||||
@ -1,14 +0,0 @@
|
||||
#include "../lib/asynco_default.hpp"
|
||||
using namespace marcelb::asynco;
|
||||
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
|
||||
int main() {
|
||||
asynco_default_run();
|
||||
|
||||
// code
|
||||
|
||||
asynco_default_join();
|
||||
return 0;
|
||||
}
|
||||
@ -1,16 +0,0 @@
|
||||
#include "../lib/asynco.hpp"
|
||||
using namespace marcelb::asynco;
|
||||
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
|
||||
int main() {
|
||||
|
||||
Asynco asynco;
|
||||
asynco.run(2);
|
||||
|
||||
// code
|
||||
|
||||
asynco.join();
|
||||
return 0;
|
||||
}
|
||||
@ -1,41 +0,0 @@
|
||||
#include "../lib/asynco.hpp"
|
||||
using namespace marcelb::asynco;
|
||||
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
|
||||
int main() {
|
||||
Asynco asynco;
|
||||
asynco.run(2);
|
||||
|
||||
Timer inter1 = asynco.periodic ([]() {
|
||||
cout << "Interval 1" << endl;
|
||||
}, 1000);
|
||||
|
||||
// stop periodic
|
||||
inter1.stop();
|
||||
|
||||
// how many times it has expired
|
||||
int ti = inter1.ticks();
|
||||
|
||||
// is it stopped
|
||||
bool stoped_i = inter1.stoped();
|
||||
|
||||
// start delayed
|
||||
Timer time1 = asynco.delayed ( [] () {
|
||||
cout << "Timeout 1 " << endl;
|
||||
}, 10000);
|
||||
|
||||
// stop delayed
|
||||
time1.stop();
|
||||
|
||||
// is it expired
|
||||
int tt = time1.expired();
|
||||
|
||||
// is it stopped
|
||||
bool stoped_t = time1.stoped();
|
||||
|
||||
|
||||
asynco.join();
|
||||
return 0;
|
||||
}
|
||||
@ -1,40 +0,0 @@
|
||||
#include "../lib/asynco_default.hpp"
|
||||
using namespace marcelb::asynco;
|
||||
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
|
||||
|
||||
int main() {
|
||||
asynco_default_run();
|
||||
|
||||
Timer inter1 = periodic ([]() {
|
||||
cout << "Interval 1" << endl;
|
||||
}, 1000);
|
||||
|
||||
// stop periodic
|
||||
// inter1.stop();
|
||||
|
||||
// how many times it has expired
|
||||
int ti = inter1.ticks();
|
||||
|
||||
// is it stopped
|
||||
bool stoped_i = inter1.stoped();
|
||||
|
||||
// start delayed
|
||||
Timer time1 = delayed ( [] () {
|
||||
cout << "Timeout 1 " << endl;
|
||||
}, 10000);
|
||||
|
||||
// stop delayed
|
||||
// time1.stop();
|
||||
|
||||
// is it expired
|
||||
int tt = time1.expired();
|
||||
|
||||
// is it stopped
|
||||
bool stoped_t = time1.stoped();
|
||||
|
||||
asynco_default_join();
|
||||
return 0;
|
||||
}
|
||||
@ -1,124 +0,0 @@
|
||||
#include "../lib/asynco.hpp"
|
||||
using namespace marcelb::asynco;
|
||||
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
|
||||
Asynco asynco;
|
||||
|
||||
class ClassWithTriggers {
|
||||
Trigger<int> emitter1;
|
||||
Trigger<string> emitter2;
|
||||
|
||||
public:
|
||||
ClassWithTriggers(): emitter1(asynco), emitter2(asynco) {}
|
||||
|
||||
template<typename... T>
|
||||
void on(const string& key, function<void(T...)> callback) {
|
||||
if constexpr (sizeof...(T) == 1 && is_same_v<tuple_element_t<0, tuple<T...>>, int>) {
|
||||
emitter1.on(key, callback);
|
||||
}
|
||||
else if constexpr (sizeof...(T) == 1 && is_same_v<tuple_element_t<0, tuple<T...>>, string>) {
|
||||
emitter2.on(key, callback);
|
||||
}
|
||||
}
|
||||
|
||||
template <typename... Args>
|
||||
void tick(const string& key, Args&&... args) {
|
||||
if constexpr (sizeof...(Args) == 1 && is_same_v<tuple_element_t<0, tuple<Args...>>, int>) {
|
||||
emitter1.tick(key, forward<Args>(args)...);
|
||||
}
|
||||
else if constexpr (sizeof...(Args) == 1 && is_same_v<tuple_element_t<0, tuple<Args...>>, string>) {
|
||||
emitter2.tick(key, forward<Args>(args)...);
|
||||
}
|
||||
else {
|
||||
static_assert(sizeof...(Args) == 0, "Unsupported number or types of arguments");
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
int main() {
|
||||
asynco.run(2);
|
||||
|
||||
/**
|
||||
* initialization of typed events
|
||||
*/
|
||||
|
||||
Trigger<int, int> ev2int = asynco.trigger<int, int>();
|
||||
Trigger<int, string> evintString = asynco.trigger<int, string>();
|
||||
Trigger<> evoid = asynco.trigger<>();
|
||||
|
||||
|
||||
ev2int.on("sum", [](int a, int b) {
|
||||
cout << "Sum " << a+b << endl;
|
||||
});
|
||||
|
||||
evintString.on("substract", [](int a, string b) {
|
||||
cout << "Substract " << a-stoi(b) << endl;
|
||||
});
|
||||
|
||||
evoid.on("void", []() {
|
||||
cout << "Void emited" << endl;
|
||||
});
|
||||
|
||||
// multiple listeners
|
||||
|
||||
string emited2 = "2";
|
||||
|
||||
evoid.on("void", [&]() {
|
||||
cout << "Void emited " << emited2 << endl;
|
||||
});
|
||||
|
||||
sleep(1);
|
||||
|
||||
/**
|
||||
* Emit
|
||||
*/
|
||||
|
||||
ev2int.tick("sum", 5, 8);
|
||||
|
||||
sleep(1);
|
||||
evintString.tick("substract", 3, to_string(2));
|
||||
|
||||
sleep(1);
|
||||
evoid.tick("void");
|
||||
|
||||
// Turn off the event listener
|
||||
|
||||
evoid.off("void");
|
||||
evoid.tick("void"); // nothing is happening
|
||||
|
||||
|
||||
class myOwnClass : public Trigger<int> {
|
||||
public:
|
||||
myOwnClass() : Trigger(asynco) {};
|
||||
};
|
||||
|
||||
myOwnClass myclass;
|
||||
|
||||
Timer t = asynco.delayed( [&] {
|
||||
myclass.tick("constructed", 1);
|
||||
}, 200);
|
||||
|
||||
myclass.on("constructed", [] (int i) {
|
||||
cout << "Constructed " << i << endl;
|
||||
});
|
||||
|
||||
|
||||
ClassWithTriggers mt;
|
||||
|
||||
mt.on<int>("int", function<void(int)>([&](int i) {
|
||||
cout << "Emit int " << i << endl;
|
||||
}));
|
||||
|
||||
mt.on<string>("string", function<void(string)>([&](string s) {
|
||||
cout << "Emit string " << s << endl;
|
||||
}));
|
||||
|
||||
mt.tick("int", 5);
|
||||
mt.tick("string", string("Hello world"));
|
||||
|
||||
|
||||
asynco.join();
|
||||
return 0;
|
||||
}
|
||||
@ -1,118 +0,0 @@
|
||||
#include "../lib/asynco_default.hpp"
|
||||
using namespace marcelb::asynco;
|
||||
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
|
||||
class ClassWithTriggers {
|
||||
Trigger<int> emitter1;
|
||||
Trigger<string> emitter2;
|
||||
|
||||
public:
|
||||
ClassWithTriggers(): emitter1(asynco_default_runtime()), emitter2(asynco_default_runtime()) {}
|
||||
|
||||
template<typename... T>
|
||||
void on(const string& key, function<void(T...)> callback) {
|
||||
if constexpr (sizeof...(T) == 1 && is_same_v<tuple_element_t<0, tuple<T...>>, int>) {
|
||||
emitter1.on(key, callback);
|
||||
}
|
||||
else if constexpr (sizeof...(T) == 1 && is_same_v<tuple_element_t<0, tuple<T...>>, string>) {
|
||||
emitter2.on(key, callback);
|
||||
}
|
||||
}
|
||||
|
||||
template <typename... Args>
|
||||
void tick(const string& key, Args&&... args) {
|
||||
if constexpr (sizeof...(Args) == 1 && is_same_v<tuple_element_t<0, tuple<Args...>>, int>) {
|
||||
emitter1.tick(key, forward<Args>(args)...);
|
||||
}
|
||||
else if constexpr (sizeof...(Args) == 1 && is_same_v<tuple_element_t<0, tuple<Args...>>, string>) {
|
||||
emitter2.tick(key, forward<Args>(args)...);
|
||||
}
|
||||
else {
|
||||
static_assert(sizeof...(Args) == 0, "Unsupported number or types of arguments");
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
int main() {
|
||||
asynco_default_run();
|
||||
|
||||
/**
|
||||
* initialization of typed events
|
||||
*/
|
||||
|
||||
Trigger<int, int> ev2int = trigger<int, int>();
|
||||
Trigger<int, string> evintString = trigger<int, string>();
|
||||
Trigger<> evoid = trigger<>();
|
||||
|
||||
ev2int.on("sum", [](int a, int b) {
|
||||
cout << "Sum " << a+b << endl;
|
||||
});
|
||||
|
||||
evintString.on("substract", [](int a, string b) {
|
||||
cout << "Substract " << a-stoi(b) << endl;
|
||||
});
|
||||
|
||||
evoid.on("void", []() {
|
||||
cout << "Void emited" << endl;
|
||||
});
|
||||
|
||||
// multiple listeners
|
||||
|
||||
string emited2 = "2";
|
||||
|
||||
evoid.on("void", [&]() {
|
||||
cout << "Void emited " << emited2 << endl;
|
||||
});
|
||||
|
||||
sleep(1);
|
||||
|
||||
/**
|
||||
* Emit
|
||||
*/
|
||||
|
||||
ev2int.tick("sum", 5, 8);
|
||||
|
||||
sleep(1);
|
||||
evintString.tick("substract", 3, to_string(2));
|
||||
|
||||
sleep(1);
|
||||
evoid.tick("void");
|
||||
|
||||
// Turn off the event listener
|
||||
|
||||
evoid.off("void");
|
||||
evoid.tick("void"); // nothing is happening
|
||||
|
||||
class myOwnClass : public Trigger<int> {
|
||||
public:
|
||||
myOwnClass() : Trigger(asynco_default_runtime()) {};
|
||||
};
|
||||
|
||||
myOwnClass myclass;
|
||||
|
||||
Timer t = delayed( [&] {
|
||||
myclass.tick("constructed", 1);
|
||||
}, 200);
|
||||
|
||||
myclass.on("constructed", [] (int i) {
|
||||
cout << "Constructed " << i << endl;
|
||||
});
|
||||
|
||||
ClassWithTriggers mt;
|
||||
|
||||
mt.on<int>("int", function<void(int)>([&](int i) {
|
||||
cout << "Emit int " << i << endl;
|
||||
}));
|
||||
|
||||
mt.on<string>("string", function<void(string)>([&](string s) {
|
||||
cout << "Emit string " << s << endl;
|
||||
}));
|
||||
|
||||
mt.tick("int", 5);
|
||||
mt.tick("string", string("Hello world"));
|
||||
|
||||
asynco_default_join();
|
||||
return 0;
|
||||
}
|
||||
405
test/test.cpp
Normal file
405
test/test.cpp
Normal file
@ -0,0 +1,405 @@
|
||||
// // #define NUM_OF_RUNNERS 2
|
||||
|
||||
#include "../lib/asynco.hpp"
|
||||
#include "../lib/trigger.hpp"
|
||||
#include "../lib/filesystem.hpp"
|
||||
#include "../lib/timers.hpp"
|
||||
#include "../lib/define.hpp"
|
||||
|
||||
using namespace marcelb::asynco;
|
||||
using namespace triggers;
|
||||
|
||||
#include <iostream>
|
||||
#include <unistd.h>
|
||||
#include <thread>
|
||||
#include <future>
|
||||
#include <vector>
|
||||
|
||||
using namespace std;
|
||||
using namespace this_thread;
|
||||
|
||||
|
||||
|
||||
void sleep_to (int _time) {
|
||||
promise<void> _promise;
|
||||
delayed t( [&]() {
|
||||
_promise.set_value();
|
||||
}, _time);
|
||||
|
||||
return _promise.get_future().get();
|
||||
}
|
||||
|
||||
void promise_reject (int _time) {
|
||||
promise<void> _promise;
|
||||
delayed t( [&]() {
|
||||
try {
|
||||
// simulate except
|
||||
throw runtime_error("Error simulation");
|
||||
_promise.set_value();
|
||||
} catch (...) {
|
||||
_promise.set_exception(current_exception());
|
||||
}
|
||||
}, _time);
|
||||
|
||||
return _promise.get_future().get();
|
||||
}
|
||||
|
||||
void notLambdaFunction() {
|
||||
cout << "Call to not lambda function" << endl;
|
||||
}
|
||||
|
||||
class clm {
|
||||
public:
|
||||
void classMethode() {
|
||||
cout << "Call class method" << endl;
|
||||
}
|
||||
};
|
||||
|
||||
// ------------------ EXTEND OWN CLASS WITH EVENTS -------------------
|
||||
|
||||
class myOwnClass : public trigger<int> {
|
||||
public:
|
||||
myOwnClass() : trigger() {};
|
||||
};
|
||||
|
||||
|
||||
int main () {
|
||||
|
||||
auto start = rtime_ms();
|
||||
|
||||
// --------------- TIME ASYNCHRONOUS FUNCTIONS --------------
|
||||
|
||||
/**
|
||||
* Init periodic and delayed; clear periodic and delayed
|
||||
*/
|
||||
|
||||
// periodic inter1 ([&]() {
|
||||
// cout << "periodic prvi " << rtime_ms() - start << endl;
|
||||
// }, 1000);
|
||||
|
||||
// periodic inter2 ([&]() {
|
||||
// cout << "periodic drugi " << rtime_ms() - start << endl;
|
||||
// }, 2000);
|
||||
|
||||
// periodic inter3 ([&]() {
|
||||
// cout << "periodic treći " << rtime_ms() - start << endl;
|
||||
// }, 1000);
|
||||
|
||||
// periodic inter4 ([&]() {
|
||||
// // cout << "periodic cetvrti " << rtime_ms() - start << endl;
|
||||
// cout << "Ticks " << inter3.ticks() << endl;
|
||||
// }, 500);
|
||||
|
||||
// periodic inter5 ([&]() {
|
||||
// cout << "periodic peti " << rtime_ms() - start << endl;
|
||||
// }, 2000);
|
||||
|
||||
// periodic inter6 ([&]() {
|
||||
// cout << "periodic sesti " << rtime_ms() - start << endl;
|
||||
// }, 3000);
|
||||
|
||||
// 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);
|
||||
|
||||
|
||||
// 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;
|
||||
// }
|
||||
|
||||
// // sleep(6);
|
||||
|
||||
// if (time2.expired()) {
|
||||
// cout << "isteko " << endl;
|
||||
// } else {
|
||||
// cout << "nije isteko " << endl;
|
||||
// }
|
||||
|
||||
// auto d = Delayed( [](){
|
||||
// cout << "Delayed" << endl;
|
||||
// }, 2000);
|
||||
|
||||
// auto p = Periodic( [](){
|
||||
// cout << "Periodic" << endl;
|
||||
// }, 700);
|
||||
|
||||
// Periodic( [&] (){
|
||||
// cout << "Delayed expire " << d->expired() << endl;
|
||||
// cout << "Periodic ticks " << p->ticks() << endl;
|
||||
// cout << "Delayed stoped " << d->stoped() << endl;
|
||||
// cout << "Periodic stoped " << p->stoped() << endl;
|
||||
// }, 1000);
|
||||
|
||||
// Delayed( [&](){
|
||||
// p->stop();
|
||||
// }, 10000);
|
||||
|
||||
// // // // ------------------------ MAKE FUNCTIONS ASYNCHRONOUS -------------------------
|
||||
|
||||
// // /**
|
||||
// // * Run an function asyncronic
|
||||
// // */
|
||||
|
||||
// async_ ( []() {
|
||||
// sleep_for(2s); // only for simulate log duration function
|
||||
// cout << "asynco 1" << endl;
|
||||
// return 5;
|
||||
// });
|
||||
|
||||
// /**
|
||||
// * Call not lambda function
|
||||
// */
|
||||
|
||||
// async_ (notLambdaFunction);
|
||||
|
||||
|
||||
// await_ (
|
||||
// async_ (
|
||||
// notLambdaFunction
|
||||
// )
|
||||
// );
|
||||
|
||||
|
||||
// // async(launch::async, [] () {
|
||||
// // cout << "Another thread in async style!" << endl;
|
||||
// // });
|
||||
|
||||
// // /**
|
||||
// // * Call class method
|
||||
// // */
|
||||
|
||||
// clm classes;
|
||||
// async_ ( [&classes] () {
|
||||
// classes.classMethode();
|
||||
// });
|
||||
|
||||
// sleep(5);
|
||||
|
||||
// // /**
|
||||
// // * await_ after runned as async
|
||||
// // */
|
||||
|
||||
// auto aa = async_ ( []() {
|
||||
// sleep_for(2s); // only for simulate log duration function
|
||||
// cout << "async_ 2" << endl;
|
||||
// return 5;
|
||||
// });
|
||||
|
||||
// cout << await_(aa) << endl;
|
||||
// cout << "print after async_ 2" << endl;
|
||||
|
||||
// /**
|
||||
// * await_ async function call and use i cout
|
||||
// */
|
||||
|
||||
// cout << await_(async_ ( [] () {
|
||||
// sleep_for(chrono::seconds(1)); // only for simulate log duration function
|
||||
// cout << "await_ end" << endl;
|
||||
// return 4;
|
||||
// })) << endl;
|
||||
|
||||
// /**
|
||||
// * Sleep with delayed sleep implement
|
||||
// */
|
||||
|
||||
// sleep_to(3000);
|
||||
// cout << "sleep_to " << rtime_ms() - start << endl;
|
||||
|
||||
// /**
|
||||
// * Catch promise reject
|
||||
// */
|
||||
|
||||
// try {
|
||||
// promise_reject(3000);
|
||||
// } catch (runtime_error err) {
|
||||
// cout<< err.what() << endl;
|
||||
// }
|
||||
|
||||
// cout << "promise_reject " << rtime_ms() - start << endl;
|
||||
|
||||
|
||||
// /**
|
||||
// * Nested asynchronous invocation
|
||||
// */
|
||||
|
||||
|
||||
// async_ ( [] {
|
||||
// cout << "idemo ..." << endl;
|
||||
// async_ ( [] {
|
||||
// cout << "ugdnježdena async funkcija " << endl;
|
||||
// });
|
||||
// });
|
||||
|
||||
|
||||
// // -------------------------- AWAIT ALL ----------------------------------
|
||||
|
||||
// auto a = async_ ( []() {
|
||||
// cout << "A" << endl;
|
||||
// return 3;
|
||||
// });
|
||||
|
||||
// auto b = async_ ( []() {
|
||||
// cout << "B" << endl;
|
||||
// throw runtime_error("Test exception");
|
||||
// return;
|
||||
// });
|
||||
|
||||
// auto c = async_ ( []() {
|
||||
// cout << "C" << endl;
|
||||
// return "Hello";
|
||||
// });
|
||||
|
||||
// int a_;
|
||||
// string c_;
|
||||
|
||||
// auto await_all = [&] () {
|
||||
// a_ = await_(a);
|
||||
// await_(b);
|
||||
// c_ = await_(c);
|
||||
// };
|
||||
|
||||
// try {
|
||||
// await_all();
|
||||
// cout << "a_ " << a_ << " c_ " << c_ << endl;
|
||||
// } catch (const exception& exc) {
|
||||
// cout << exc.what() << endl;
|
||||
// }
|
||||
|
||||
// // // same type
|
||||
|
||||
// vector<future<void>> fut_vec;
|
||||
// for (int i=0; i<5; i++) {
|
||||
// fut_vec.push_back(
|
||||
// async_ ( [i]() {
|
||||
// cout << "Async_ " << i << endl;
|
||||
// })
|
||||
// );
|
||||
// }
|
||||
|
||||
// auto await_all2 = [&] () {
|
||||
// for (int i=0; i<fut_vec.size(); i++) {
|
||||
// await_ (fut_vec[i]);
|
||||
// }
|
||||
// };
|
||||
|
||||
// await_all2();
|
||||
|
||||
// // --------------- EVENTS -------------------
|
||||
|
||||
// /**
|
||||
// * initialization of typed events
|
||||
// */
|
||||
|
||||
// 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 done" << endl;
|
||||
// });
|
||||
|
||||
// evintString.on("substract", [](int a, string b) {
|
||||
// cout << "Substract " << a-stoi(b) << endl;
|
||||
// });
|
||||
|
||||
// evoid.on("void", []() {
|
||||
// cout << "Void emited" << endl;
|
||||
// });
|
||||
|
||||
// string emited2 = "2";
|
||||
|
||||
// evoid.on("void", [&]() {
|
||||
// cout << "Void emited " << emited2 << endl;
|
||||
// });
|
||||
|
||||
// evoid.tick("void");
|
||||
// sleep(1);
|
||||
|
||||
// /**
|
||||
// * Emit
|
||||
// */
|
||||
|
||||
// ev2int.tick("sum", 5, 8);
|
||||
|
||||
|
||||
// sleep(1);
|
||||
// evintString.tick("substract", 3, to_string(2));
|
||||
|
||||
// sleep(1);
|
||||
// evoid.off("void");
|
||||
// evoid.tick("void");
|
||||
|
||||
|
||||
// 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;
|
||||
|
||||
// /**
|
||||
// * Own class
|
||||
// */
|
||||
|
||||
// myOwnClass myclass;
|
||||
|
||||
// delayed t( [&] {
|
||||
// myclass.tick("constructed", 1);
|
||||
// }, 200);
|
||||
|
||||
// myclass.on("constructed", [] (int i) {
|
||||
// cout << "Constructed " << i << endl;
|
||||
// });
|
||||
|
||||
|
||||
|
||||
// auto status = fs::read("test1.txt");
|
||||
|
||||
|
||||
// try {
|
||||
// auto data = await_(status);
|
||||
// cout << data;
|
||||
// } catch (exception& err) {
|
||||
// cout << err.what() << 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();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user