Compare commits

..

No commits in common. "dev" and "dev-asio-engine" have entirely different histories.

27 changed files with 955 additions and 1446 deletions

5
.gitignore vendored
View File

@ -1,3 +1,2 @@
build
.vscode
example
test/test
test/*.txt

16
.vscode/c_cpp_properties.json vendored Normal file
View 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
}

74
.vscode/settings.json vendored Normal file
View File

@ -0,0 +1,74 @@
{
"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"
}
}

28
.vscode/tasks.json vendored Normal file
View 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"
}

View File

@ -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)
#

310
README.md
View File

@ -1,90 +1,54 @@
# 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.
## 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 asynchronous filesystem was included solely to demonstrate how users can wrap any time- or I/O-intensive functions for asynchronous execution.
A C++ library for event-driven asynchronous multi-threaded programming.
## Features
- Object oriented
- Small and easy to integrate
- Header only
- Asynchronous programming
- Multithread
- Asynchronous timer functions: Periodic, Delayed (like setInterval and setTimeout from JS)
- Typed events (on, tick, off) (like EventEmitter from JS: on, emit, etc)
- Asynchronous timer functions: interval, timeout
- Typed events (on, emit, off)
- 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 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
using namespace marcelb;
using namespace asynco;
using namespace events;
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 ([]() {
// start interval
interval 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
// stop interval
inter1.stop();
// how many times it has expired
@ -93,12 +57,12 @@ int t = inter1.ticks();
// is it stopped
bool stoped = inter1.stoped();
// start delayed
Timer time1 = delayed( [] () {
// start timeout
timeout time1 ( [] () {
cout << "Timeout 1 " << endl;
}, 10000);
// stop delayed
// stop timeout
time1.stop();
// is it expired
@ -108,18 +72,16 @@ int t = time1.expired();
bool stoped = time1.stoped();
```
### Make functions asynchronous
Running functions at runtime, asynchronous execution, uses the `async_` call and its return type is `std::future<T>`
Make functions asynchronous
```c++
/**
* Run an lambda function asynchronously
*/
async_ ( []() {
sleep(2); // only for simulating long duration function
cout << "nonsync " << endl;
atask( []() {
sleep_for(2s); // only for simulating long duration function
cout << "atask" << endl;
return 5;
});
@ -132,7 +94,7 @@ void notLambdaFunction() {
cout << "Call to not lambda function" << endl;
}
async_ (notLambdaFunction);
atask (notLambdaFunction);
/**
* Run class method
@ -146,58 +108,84 @@ class clm {
};
clm classes;
async_ ( [&classes] () {
atask( [&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++
auto a = async_ ( []() {
sleep(2); // only for simulating long duration function
cout << "nonsync " << endl;
/**
* Wait after runned as async
*/
auto a = atask( []() {
sleep_for(2s); // only for simulating long duration function
cout << "atask" << endl;
return 5;
});
cout << await_(a) << endl;
cout << wait(a) << endl;
/**
* await_ async function call and use i cout
* Wait async function call and use i cout
*/
cout << await_(async_ ( [] () {
sleep(1); // only for simulating long duration function
cout << "await_ end" << endl;
cout << wait(atask( [] () {
sleep_for(chrono::seconds(1)); // only for simulating long duration function
cout << "wait end" << endl;
return 4;
})) << endl;
/**
* Sleep with timeout sleep implement
*/
void sleep_to (int _time) {
promise<void> _promise;
timeout t( [&]() {
_promise.set_value();
}, _time);
return _promise.get_future().get();
}
sleep_to(3000);
/**
* Catch promise reject
*/
void promise_reject (int _time) {
promise<void> _promise;
timeout 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;
}
```
If you want to run asynchronously but need the result immediately, you can use a shorter notation
```c++
await_ ([]() {
cout << "Hello" << 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<>();
event<int, int> ev2int;
event<int, string> evintString;
event<> evoid;
ev2int.on("sum", [](int a, int b) {
cout << "Sum " << a+b << endl;
@ -225,32 +213,32 @@ sleep(1);
* Emit
*/
ev2int.tick("sum", 5, 8);
ev2int.emit("sum", 5, 8);
sleep(1);
evintString.tick("substract", 3, to_string(2));
evintString.emit("substract", 3, to_string(2));
sleep(1);
evoid.tick("void");
evoid.emit("void");
// Turn off the event listener
evoid.off("void");
evoid.tick("void"); // nothing is happening
evoid.emit("void"); // nothing is happening
```
Extend own class whit events
```c++
class myOwnClass : public Trigger<int> {
class myOwnClass : public event<int> {
public:
myOwnClass() : Trigger(asynco_default_runtime()) {};
myOwnClass() : event() {};
};
myOwnClass myclass;
Delayed t( [&] {
myclass.tick("constructed", 1);
timeout t( [&] {
myclass.emit("constructed", 1);
}, 200);
myclass.on("constructed", [] (int i) {
@ -259,110 +247,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 = wait(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 {
wait(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

View File

@ -1,187 +1,85 @@
#ifndef _ASYNCO_
#define _ASYNCO_
#include <vector>
#include <memory>
#include <type_traits>
#include <thread>
#include <future>
#include <functional>
#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 <iostream>
#include "timers.hpp"
#include "trigger.hpp"
using namespace std;
namespace marcelb {
namespace asynco {
#define HW_CONCURRENCY_MINIMAL 4
/**
* Asynco runtime
* Used for all asynchronous capabilities of this wrapper
* Initializes threads and boost::asio::io_context
* 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 Asynco {
vector<thread> _runners;
unique_ptr<io_service::work> _work;
class {
public:
boost::asio::io_context io_context;
void init_loops_in_threads(uint8_t threads);
public:
io_context io_ctx;
/**
* 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() {
for (auto& runner : runners) {
runner.join();
}
}
void run_on_this();
private:
/**
* Waits until all threads have finished working
*/
unique_ptr<boost::asio::io_service::work> work { [&] () {
return new boost::asio::io_service::work(io_context);
} ()};
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;
}
#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
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;
}
}, boost::asio::detached);
#endif
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();
for (int i=0; i<num_of_runners; i++) {
_runs.push_back(thread ( [this] () {
io_context.run();
}));
}
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();
}
return _runs;
} ()};
/**
* 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...)
);
}
} _asynco_engine;
#if __cplusplus >= 202002L
/**
* Run the coruotine and wait
*/
template <typename T>
T await(boost::asio::awaitable<T> _coroutine) {
return await(
async(
move(_coroutine)
));
}
#endif
/**
* Run the function asynchronously
*/
template<class F, class... Args>
auto atask(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;
}
/**
* 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
*/
template<typename T>
T wait(future<T>& r) {
return r.get();
}
/**
* Block until the asynchronous call completes
*/
template<typename T>
T wait(future<T>&& r) {
return move(r).get();
}
}
}

View File

@ -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

65
lib/event.hpp Normal file
View File

@ -0,0 +1,65 @@
#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

115
lib/filesystem.hpp Normal file
View 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) {
atask( [&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 atask( [&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) {
atask( [&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 atask( [&path, &content] () {
ofstream file (path);
if (file.is_open()) {
file << content;
file.close();
return;
}
else {
throw runtime_error("Unable to open file");
}
});
}
}
}
}
#endif

View File

@ -1,12 +1,12 @@
#ifndef _ASYNCO_TIMERS_
#define _ASYNCO_TIMERS_
#ifndef _ROTOR_
#define _ROTOT_
#include "asynco.hpp"
#include <chrono>
#include <iostream>
using namespace std;
#include <boost/asio.hpp>
using namespace boost::asio;
using namespace std;
using namespace marcelb;
using namespace asynco;
namespace marcelb {
namespace asynco {
@ -15,27 +15,29 @@ namespace asynco {
* Get the time in ms from the epoch
*/
int64_t rtime_ms();
int64_t rtime_ms() {
return chrono::duration_cast<chrono::milliseconds>(chrono::system_clock::now()
.time_since_epoch())
.count();
}
/**
* Get the time in us from the epoch
*/
int64_t rtime_us();
enum TimerType {
Delayed,
Periodic
};
int64_t rtime_us() {
return chrono::duration_cast<chrono::microseconds>(chrono::system_clock::now()
.time_since_epoch())
.count();
}
/**
* 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,47 +45,177 @@ class Timer {
/**
* A method to assign a callback wrapper and a reinitialization algorithm
*/
void init();
void init() {
st.async_wait( [this] (const boost::system::error_code&) {
if (!_stop) {
callback();
if (repeate) {
st = boost::asio::steady_timer(_asynco_engine.io_context, boost::asio::chrono::milliseconds(time));
init();
}
_ticks++;
}
});
}
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) :
st(_asynco_engine.io_context, boost::asio::chrono::milliseconds(_time)),
_stop(false),
repeate(_repeate),
callback(_callback),
time(_time) {
init();
}
/**
* Stop timer
* The stop flag is set and timer remove it from the queue
*/
void stop();
void stop() {
_stop = true;
st.cancel();
}
/**
* Run callback now
* Forces the callback function to run independently of the timer
*/
void now();
void now() {
st.cancel();
}
/**
* Get the number of times the timer callback was runned
*/
uint64_t ticks();
/**
* Get is the delayed callback runned
*/
bool expired();
uint64_t ticks() {
return _ticks;
}
/**
* The logic status of the timer stop state
*/
bool stoped();
bool stoped() {
return _stop;
}
/**
* The destructor stops the timer
*/
~Timer();
~timer() {
stop();
}
};
/**
* Class interval for periodic execution of the callback in time in ms
*/
class interval {
shared_ptr<timer> _timer;
public:
/**
* Constructor initializes a shared pointer of type timer
*/
interval(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
*/
void stop() {
_timer->stop();
}
/**
* Run callback now
* Forces the callback function to run independently of the interval
*/
void now() {
_timer->now();
}
/**
* Get the number of times the interval callback was runned
*/
uint64_t ticks() {
return _timer->ticks();
}
/**
* The logic status of the interval stop state
*/
bool stoped() {
return _timer->stoped();
}
/**
* The destructor stops the interval
*/
~interval() {
stop();
}
};
/**
* Class timeout for delayed callback execution in ms
*/
class timeout {
shared_ptr<timer> _timer;
public:
/**
* Constructor initializes a shared pointer of type timer
*/
timeout(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
*/
void stop() {
_timer->stop();
}
/**
* Run callback now
* Forces the callback function to run independently of the timeout
*/
void now() {
_timer->now();
}
/**
* Get the number of times the timeout callback was runned
*/
bool expired() {
return bool(_timer->ticks());
}
/**
* The logic status of the timeout stop state
*/
bool stoped() {
return _timer->stoped();
}
/**
* The destructor stops the timeout
*/
~timeout() {
stop();
}
};
}
}

View File

@ -1,95 +0,0 @@
#ifndef _ASYNCO_TRIGGER_
#define _ASYNCO_TRIGGER_
#include <map>
#include <vector>
#include <string>
#include <functional>
using namespace std;
#include "asynco.hpp"
namespace marcelb {
namespace asynco {
class Asynco;
/**
* Trigger class, for event-driven programming.
* These events are typed according to the arguments of the callback function
*/
template<typename... T>
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
*/
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)...);
engine.async(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

View File

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

View File

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

View File

@ -1,65 +0,0 @@
#include "../lib/timers.hpp"
namespace marcelb::asynco {
int64_t rtime_ms() {
return std::chrono::duration_cast<std::chrono::milliseconds>(std::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()
.time_since_epoch())
.count();
}
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));
init();
}
_ticks++;
}
});
}
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)),
_stop(false),
type(_type),
callback(_callback),
time(_time) {
init();
}
void Timer::stop() {
_stop = true;
st.cancel();
}
void Timer::now() {
st.cancel();
}
uint64_t Timer::ticks() {
return _ticks;
}
bool Timer::expired() {
return bool(_ticks);
}
bool Timer::stoped() {
return _stop;
}
Timer::~Timer() {
stop();
}
};

View File

@ -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)

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

317
test/test.cpp Normal file
View File

@ -0,0 +1,317 @@
// #define NUM_OF_RUNNERS 2
#include "../lib/asynco.hpp"
#include "../lib/event.hpp"
#include "../lib/filesystem.hpp"
#include "../lib/timers.hpp"
using namespace marcelb::asynco;
using namespace events;
#include <iostream>
#include <unistd.h>
#include <thread>
using namespace std;
using namespace this_thread;
void sleep_to (int _time) {
promise<void> _promise;
timeout t( [&]() {
_promise.set_value();
}, _time);
return _promise.get_future().get();
}
void promise_reject (int _time) {
promise<void> _promise;
timeout 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 event<int> {
public:
myOwnClass() : event() {};
};
int main () {
auto start = rtime_ms();
// --------------- TIME ASYNCHRONOUS FUNCTIONS --------------
// /**
// * Init interval and timeout; clear interval and timeout
// */
// interval inter1 ([&]() {
// cout << "interval prvi " << rtime_ms() - start << endl;
// }, 1000);
// interval inter2 ([&]() {
// cout << "interval drugi " << rtime_ms() - start << endl;
// }, 2000);
// interval inter3 ([&]() {
// cout << "interval treći " << rtime_ms() - start << endl;
// }, 1000);
// interval inter4 ([&]() {
// // cout << "interval cetvrti " << rtime_ms() - start << endl;
// cout << "Ticks " << inter3.ticks() << endl;
// }, 500);
// interval inter5 ([&]() {
// cout << "interval peti " << rtime_ms() - start << endl;
// }, 2000);
// interval inter6 ([&]() {
// cout << "interval 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);
// timeout time2 ([&] () {
// cout << "Close interval 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;
// }
// // // ------------------------ MAKE FUNCTIONS ASYNCHRONOUS -------------------------
// /**
// * Run an function asyncronic
// */
// atask( []() {
// sleep_for(2s); // only for simulate log duration function
// cout << "atask 1" << endl;
// return 5;
// });
// /**
// * Call not lambda function
// */
// atask (notLambdaFunction);
// wait (
// atask (
// notLambdaFunction
// )
// );
// /**
// * Call class method
// */
// clm classes;
// atask( [&classes] () {
// classes.classMethode();
// });
// sleep(5);
// /**
// * Wait after runned as async
// */
// 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;
// /**
// * 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;
// /**
// * Sleep with timeout 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
// */
// atask( [] {
// cout << "idemo ..." << endl;
// atask( [] {
// cout << "ugdnježdena async funkcija " << endl;
// });
// });
// // // --------------- EVENTS -------------------
// /**
// * initialization of typed events
// */
// 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 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.emit("void");
// sleep(1);
// /**
// * Emit
// */
// ev2int.emit("sum", 5, 8);
// sleep(1);
// evintString.emit("substract", 3, to_string(2));
// sleep(1);
// evoid.off("void");
// evoid.emit("void");
// /**
// * Own class
// */
// myOwnClass myclass;
// timeout 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;
// }
// 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;
}