Work on loop like in Rust.. ok in default

CMakeLists.txt

@@ -27,6 +27,7 @@ add_subdirectory(test)
 
 add_compile_options(-w)
 
+# add_definitions(-DASYNCO_THREADS_POOL_SIZE=20)
 
 
 # Instaliraj biblioteku

lib/asynco.hpp

@@ -18,6 +18,8 @@ using namespace std;
 #endif
 using namespace boost::asio;
 
+#define loop while(true)
+
 #include "timers.hpp"
 #include "trigger.hpp"
 
@@ -170,6 +172,12 @@ public:
 
     Timer periodic(function<void()> callback, uint64_t time);
 
+    /**
+     * Nonblock time sleep function
+     */
+
+    void sleep(int _time);
+
     /**
      * Initialize trigger (typed event)
      */

lib/asynco_default.hpp

@@ -97,6 +97,12 @@ Timer delayed(function<void()> callback, uint64_t time);
 
 Timer periodic(function<void()> callback, uint64_t time);
 
+/**
+ * Nonblock time sleep function
+ */
+
+void sleep(int _time);
+
 /**
  * Initialize trigger (typed event)
  */

src/asynco.cpp

@@ -37,5 +37,13 @@ Timer Asynco::periodic(function<void()> callback, uint64_t time) {
     return Timer(io_ctx, callback, time, TimerType::Periodic);
 }
 
+void Asynco::sleep(int _time) {
+    promise<void> _promise;
+    Timer t = delayed( [&]() {
+        _promise.set_value();
+    }, _time);
+
+    return await(_promise.get_future());
+}
 
 };

src/asynco_default.cpp

@@ -13,12 +13,20 @@ Timer periodic(function<void()> callback, uint64_t time) {
     return Timer(Asynco_Default_Runtime.io_ctx, callback, time, TimerType::Periodic);
 }
 
+void sleep(int _time) {
+    return Asynco_Default_Runtime.sleep(_time);
+}
+
 Asynco& asynco_default_runtime() {
     return Asynco_Default_Runtime;
 }
 
 void asynco_default_run() {
+#ifdef ASYNCO_THREADS_POOL_SIZE
+    Asynco_Default_Runtime.run(ASYNCO_THREADS_POOL_SIZE);
+#else
     Asynco_Default_Runtime.run();
+#endif
 }
 
 void asynco_default_run_on_this() {

test/CMakeLists.txt

@@ -26,4 +26,10 @@ 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)
+target_link_libraries(asynco_coroutine asynco Boost::system)
+
+add_executable(asynco_infinit_loop_default main_infinit_loop_default.cpp)
+target_link_libraries(asynco_infinit_loop_default asynco Boost::system)
+
+add_executable(asynco_infinit_loop main_infinit_loop.cpp)
+target_link_libraries(asynco_infinit_loop asynco Boost::system)

test/main_async_default.cpp

@@ -11,8 +11,15 @@ void notLambdaFunction() {
 
 class clm {
     public:
+    int i = 7;
     void classMethode() {
-        cout << "Call class method" << endl;
+        cout << "Call class method" << i << endl;
+    }
+
+    future<void> asyncMethode() {
+        return async_([&]() {
+            cout << "Async class method" << i << endl;
+        });
     }
 };
 
@@ -53,6 +60,8 @@ int main() {
         classes.classMethode();
     });
 
+    await_(classes.asyncMethode());
+
     //------------------AWAIT----------------------
 
     auto a = async_ ( []() {

test/main_infinit_loop.cpp

@@ -0,0 +1,111 @@
+#include "../lib/asynco.hpp"
+using namespace marcelb::asynco;
+
+#include <iostream>
+using namespace std;
+
+
+int main() {
+    Asynco asynco;
+    asynco.run(4);
+
+    asynco.async ([&](){
+        loop {
+            cout << "Loop 1" << endl;
+            asynco.sleep(1000);
+        }
+    });
+
+
+    asynco.async ([&](){
+        loop {
+            cout << "Loop 2" << endl;
+            asynco.sleep(2000);
+        }
+    });
+
+
+    asynco.async ([&](){
+        loop {
+            cout << "Loop 25" << endl;
+            asynco.sleep(2500);
+        }
+    });
+
+
+    asynco.async ([&](){
+        loop {
+            cout << "Loop 3" << endl;
+            asynco.sleep(3000);
+        }
+    });
+
+
+    asynco.async ([&](){
+        loop {
+            cout << "Loop 35" << endl;
+            asynco.sleep(3500);
+        }
+    });
+
+
+    asynco.async ([&](){
+        loop {
+            cout << "Loop 4" << endl;
+            asynco.sleep(4000);
+        }
+    });
+
+
+    asynco.async ([&](){
+        loop {
+            cout << "Loop 45" << endl;
+            asynco.sleep(4500);
+        }
+    });
+
+
+    asynco.async ([&](){
+        loop {
+            cout << "Loop 5" << endl;
+            asynco.sleep(5000);
+        }
+    });
+
+
+    asynco.async ([&](){
+        loop {
+            cout << "Loop 55" << endl;
+            asynco.sleep(5500);
+        }
+    });
+
+    asynco.async ([&](){
+        loop {
+            cout << "Loop 6" << endl;
+            asynco.sleep(6000);
+        }
+    });
+
+    asynco.async ([&](){
+        loop {
+            cout << "Loop 65" << endl;
+            asynco.sleep(6500);
+        }
+    });
+
+    asynco.async ([&](){
+        loop {
+            cout << "Loop 7" << endl;
+            asynco.sleep(7000);
+        }
+    });
+
+    loop {  // blokira trenutnu
+        cout << "Loop 15" << endl;
+        asynco.sleep(1500);
+    }
+
+    asynco.join();
+    return 0;
+}

test/main_infinit_loop_default.cpp

@@ -0,0 +1,111 @@
+#include "../lib/asynco_default.hpp"
+using namespace marcelb::asynco;
+
+#include <iostream>
+using namespace std;
+
+
+int main() {
+    asynco_default_run();
+
+
+    async_ ([](){
+        loop {
+            cout << "Loop 1" << endl;
+            sleep(1000);
+        }
+    });
+
+
+    async_ ([](){
+        loop {
+            cout << "Loop 2" << endl;
+            sleep(2000);
+        }
+    });
+
+
+    async_ ([](){
+        loop {
+            cout << "Loop 25" << endl;
+            sleep(2500);
+        }
+    });
+
+
+    async_ ([](){
+        loop {
+            cout << "Loop 3" << endl;
+            sleep(3000);
+        }
+    });
+
+
+    async_ ([](){
+        loop {
+            cout << "Loop 35" << endl;
+            sleep(3500);
+        }
+    });
+
+
+    async_ ([](){
+        loop {
+            cout << "Loop 4" << endl;
+            sleep(4000);
+        }
+    });
+
+
+    async_ ([](){
+        loop {
+            cout << "Loop 45" << endl;
+            sleep(4500);
+        }
+    });
+
+
+    async_ ([](){
+        loop {
+            cout << "Loop 5" << endl;
+            sleep(5000);
+        }
+    });
+
+
+    async_ ([](){
+        loop {
+            cout << "Loop 55" << endl;
+            sleep(5500);
+        }
+    });
+
+    async_ ([](){
+        loop {
+            cout << "Loop 6" << endl;
+            sleep(6000);
+        }
+    });
+
+    async_ ([](){
+        loop {
+            cout << "Loop 65" << endl;
+            sleep(6500);
+        }
+    });
+
+    async_ ([](){
+        loop {
+            cout << "Loop 7" << endl;
+            sleep(7000);
+        }
+    });
+
+    loop {  // blokira trenutnu
+        cout << "Loop 15" << endl;
+        sleep(1500);
+    }
+
+    asynco_default_join();
+    return 0;
+}