add eventloop implementations for call_* and call_when_*_completed functions

Author: philoinovsky

.gitignore

@@ -1,4 +1,4 @@
 bin.SCons
 *.pyc
 *~
-\#*\#
+\#*\#

include/boost/python.hpp

@@ -25,6 +25,7 @@
 # include <boost/python/docstring_options.hpp>
 # include <boost/python/enum.hpp>
 # include <boost/python/errors.hpp>
+# include <boost/python/eventloop.hpp>
 # include <boost/python/exception_translator.hpp>
 # include <boost/python/exec.hpp>
 # include <boost/python/extract.hpp>

include/boost/python/eventloop.hpp

@@ -0,0 +1,191 @@
+// Copyright Pan Yue 2021.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// TODO:
+// 1. posix::stream_descriptor need windows version
+// 2. call_* need return async.Handle
+# ifndef EVENT_LOOP_PY2021_H_
+# define EVENT_LOOP_PY2021_H_
+
+#include <mutex>
+#include <functional>
+#include <unordered_map>
+#include <boost/asio.hpp>
+#include <boost/bind.hpp>
+#include <boost/python.hpp>
+
+namespace a = boost::asio;
+namespace c = std::chrono;
+namespace py = boost::python;
+
+namespace boost { namespace python { namespace eventloop {
+
+class EventLoop
+{
+private:
+    int64_t _timer_id = 0;
+    a::io_context::strand _strand;
+    std::unordered_map<int, std::unique_ptr<a::steady_timer>> _id_to_timer_map;
+    // read: key = fd * 2 + 0, write: key = fd * 2 + 1
+    std::unordered_map<int, std::unique_ptr<a::posix::stream_descriptor>> _descriptor_map;
+    std::chrono::steady_clock::time_point _created_time;
+
+    void _add_reader_or_writer(int fd, py::object f, int key)
+    {
+        // add descriptor
+        if (_descriptor_map.find(key) == _descriptor_map.end())
+        {
+            _descriptor_map.emplace(key,
+                std::move(std::make_unique<a::posix::stream_descriptor>(_strand.context(), fd))
+            );
+        }
+
+        _descriptor_map.find(key)->second->async_wait(a::posix::descriptor::wait_type::wait_read,
+            a::bind_executor(_strand, [key, f, loop=this] (const boost::system::error_code& ec)
+            {
+                // move descriptor
+                auto iter = loop->_descriptor_map.find(key);
+                if (iter != loop->_descriptor_map.end())
+                {
+                    iter->second->release();
+                    loop->_descriptor_map.erase(iter);
+                }
+                loop->call_soon(f);
+            }));
+        return;
+    }
+
+    void _remove_reader_or_writer(int key)
+    {
+        auto iter = _descriptor_map.find(key);
+        if (iter != _descriptor_map.end())
+        {
+            iter->second->release();
+            _descriptor_map.erase(iter);
+        }
+    }
+
+public:
+    EventLoop(a::io_context& ctx): 
+        _strand{ctx}, _created_time{std::chrono::steady_clock::now()}
+    {
+    }
+
+    // TODO: An instance of asyncio.Handle is returned, which can be used later to cancel the callback.
+    inline void call_soon(py::object f)
+    {
+        _strand.post([f, loop=this] {
+            f(boost::ref(*loop));
+        });
+        return;
+    }
+
+    // TODO: implement this
+    void call_soon_thread_safe(py::object f)
+    {
+        return;
+    }
+
+    // Schedule callback to be called after the given delay number of seconds
+    // TODO: An instance of asyncio.Handle is returned, which can be used later to cancel the callback.
+    void call_later(double delay, py::object f)
+    {
+        // add timer
+        _id_to_timer_map.emplace(_timer_id,
+            std::move(std::make_unique<a::steady_timer>(_strand.context(),
+                std::chrono::steady_clock::now() + std::chrono::nanoseconds(int64_t(delay * 1e9))))
+        );
+
+        _id_to_timer_map.find(_timer_id)->second->async_wait(
+            // remove timer
+            a::bind_executor(_strand, [id=_timer_id, f, loop=this] (const boost::system::error_code& ec)
+            {
+                loop->_id_to_timer_map.erase(id);
+                loop->call_soon(f);
+            }));
+        _timer_id++;
+    }
+
+    void call_at(double when, py::object f)
+    {
+        double diff = when - time();
+        if (diff > 0)
+            return call_later(diff, f);
+        return call_soon(f);
+    }
+
+    double time()
+    {
+        auto now = std::chrono::steady_clock::now();
+        std::chrono::duration<double> diff = now - _created_time;
+        return diff.count();
+    }
+
+    // week 2 ......start......
+
+    void add_reader(int fd, py::object f)
+    {
+        _add_reader_or_writer(fd, f, fd * 2);
+    }
+
+    void remove_reader(int fd)
+    {
+        _remove_reader_or_writer(fd * 2);
+    }
+
+    void add_writer(int fd, py::object f)
+    {
+        _add_reader_or_writer(fd, f, fd * 2 + 1);
+    }
+
+    void remove_writer(int fd)
+    {
+        _remove_reader_or_writer(fd * 2 + 1);
+    }
+
+
+    void sock_recv()
+    {
+
+    }
+
+    void sock_recv_into()
+    {
+        
+    }
+
+    void sock_sendall()
+    {
+
+    }
+
+    void sock_connect()
+    {
+
+    }
+
+    void sock_accept()
+    {
+
+    }
+
+    void sock_sendfile()
+    {
+        
+    }
+
+    // week 2 ......end......
+
+    void run() 
+    {
+        _strand.context().run();
+    }
+};
+
+
+}}}
+
+
+# endif

test/Jamfile

@@ -84,6 +84,7 @@ bpl-test crossmod_exception
   : crossmod_exception.py crossmod_exception_a.cpp crossmod_exception_b.cpp
 ]
 
+[ bpl-test eventloop ]
 [ bpl-test injected ]
 [ bpl-test properties ]
 [ bpl-test return_arg ]