Cython 3.2.0__cp39-abi3-win32.whl

Cython/Includes/libcpp/condition_variable.pxd

@@ -0,0 +1,322 @@
+# cython: preliminary_late_includes_cy28=True
+
+from libcpp.mutex cimport unique_lock, mutex
+from libcpp.stop_token cimport stop_token
+from libcpp cimport bool as _bool
+
+cdef extern from "<condition_variable>" namespace "std" nogil:
+    cdef enum class cv_status:
+        no_timeout
+        timeout
+
+    cdef cppclass condition_variable:
+        cppclass native_handle_type:
+            pass
+
+        condition_variable() except+
+
+        void notify_one() noexcept
+        void notify_all() noexcept
+
+        # Be very wary of calling any of the wait functions with the GIL held.
+        # Also be a little wary of re-acquiring the GIL in the predicate
+        # (because in principle it may deadlock with the lock).
+        # The predicate should not require the GIL or throw Python exceptions.
+        void wait(unique_lock[mutex]& lock) except+
+        void wait[Predicate](unique_lock[mutex]& lock, Predicate pred) except+
+
+        cv_status wait_for[Duration](unique_lock[mutex]& lock, const Duration &duration) except+
+        _bool wait_for[Duration, Predicate](unique_lock[mutex]& lock, const Duration &duration, Predicate pred) except+
+        cv_status wait_until[TimePoint](unique_lock[mutex]& lock, const TimePoint& time_point) except+
+        _bool wait_until[TimePoint, Predicate](unique_lock[mutex]& lock, const TimePoint& time_point, Predicate pred) except+
+
+        native_handle_type native_handle() except+
+
+    cdef cppclass condition_variable_any:
+        condition_variable_any() except+
+
+        void notify_one() noexcept
+        void notify_all() noexcept
+
+        # Be very wary of calling any of the wait functions with the GIL held.
+        # Also be a little wary of re-acquiring the GIL in the predicate
+        # (because in principle it may deadlock with the lock).
+        # The predicate should not require the GIL or throw Python exceptions.
+        void wait[Lock](Lock& lock) except+
+        void wait[Lock, Predicate](Lock& lock, Predicate pred) except+
+        _bool wait[Lock, Predicate](Lock& lock, stop_token stoken, Predicate pred) except+
+
+        cv_status wait_for[Lock, Duration](Lock& lock, const Duration &duration) except+
+        _bool wait_for[Lock, Duration, Predicate](Lock& lock, const Duration &duration, Predicate pred) except+
+        _bool wait_for[Lock, Duration, Predicate](Lock& lock, stop_token stoken, const Duration &duration, Predicate pred) except+
+        cv_status wait_until[Lock, TimePoint](Lock& lock, const TimePoint &time_point) except+
+        _bool wait_until[Lock, TimePoint, Predicate](Lock& lock, const TimePoint &time_point, Predicate pred) except+
+        _bool wait_until[Lock, TimePoint, Predicate](Lock& lock, stop_token stoken, const TimePoint &time_point, Predicate pred) except+
+
+    void notify_all_at_thread_exit(condition_variable& cv, unique_lock[mutex]& lock) except+
+
+cdef inline void _dummy_force_utility_code_inclusion() nogil:
+    with nogil:
+        pass
+
+cdef extern from *:
+    """
+    namespace {
+
+    template <typename Lock>
+    void __Pyx_libcpp_cv_relock_at_end(Lock& lock, __Pyx_UnknownThreadState &ts) {
+        if (__Pyx_UnknownThreadStateMayHaveHadGil(ts)) {
+            lock.unlock();  // unlocking should not throw
+            __Pyx_RestoreUnknownThread(ts);
+            // ensure_gil, release_gil and py_safe_std_lock are defined in mutex.pdx
+            PyGILState_STATE gil_state = __pyx_libcpp_mutex_limited_api_ensure_gil();
+            auto cleanup = __pyx_make_libcpp_mutex_cleanup_on_exit([&gil_state](){
+                __pyx_libcpp_mutex_limited_api_release_gil(gil_state);
+            });
+            __pyx_py_safe_std_lock(lock);
+        } else {
+            __Pyx_RestoreUnknownThread(ts);
+        }
+    }
+
+    template <typename Lock, typename Predicate>
+    class __Pyx_libcpp_cv_WrappedPySafePredicate {
+        Lock *lock;
+        Predicate *pred;
+        __Pyx_UnknownThreadState *ts;
+    public:
+        __Pyx_libcpp_cv_WrappedPySafePredicate(Lock *l, Predicate *p, __Pyx_UnknownThreadState *ts)
+            : lock(l)
+            , pred(p)
+            , ts(ts)
+        {}
+
+        bool operator()() const {
+            PyGILState_STATE gil_state;
+            lock->unlock();
+            int had_gil_on_call = __Pyx_UnknownThreadStateDefinitelyHadGil(*ts);
+            if (had_gil_on_call) {
+                __Pyx_RestoreUnknownThread(*ts);
+            } else {
+                gil_state = PyGILState_Ensure();
+            }
+            auto release_gil = __pyx_make_libcpp_mutex_cleanup_on_exit(
+                [&]() {
+                    if (had_gil_on_call) {
+                        *ts = __Pyx_SaveUnknownThread();
+                    } else {
+                        PyGILState_Release(gil_state);
+                    }
+                });
+            __pyx_py_safe_std_lock(*lock);
+            // No need to unlock - the condition variable is responsible for that and it shouldn't be possible
+            // to deadlock from here.
+            bool result = (*pred)();
+            if (PyErr_Occurred()) {
+                // The PyErr_Occurred check in __Pyx_CppExn2PyErr will deal with
+                // presenting the exception to Cython.
+                throw std::exception();
+            }
+            return result;
+        }
+    };
+
+    template <typename Lock, typename Predicate>
+    __Pyx_libcpp_cv_WrappedPySafePredicate<Lock, Predicate> __Pyx_libcpp_cv_py_safe_wrap_predicate(Lock* lock, Predicate* pred, __Pyx_UnknownThreadState* ts) {
+        return __Pyx_libcpp_cv_WrappedPySafePredicate<Lock, Predicate>(lock, pred, ts);
+    }
+
+    class __Pyx_libcpp_cv_WrappedPyObjectPredicate {
+        PyObject *pred; // unowned
+    public:
+        explicit __Pyx_libcpp_cv_WrappedPyObjectPredicate(PyObject *pred) : pred(pred) {}
+
+        bool operator()() const {
+            PyObject *res = PyObject_CallObject(pred, nullptr);
+            if (res) {
+                auto is_true = PyObject_IsTrue(res);
+                Py_DECREF(res);
+                return is_true; // exceptions don't matter - we have a PyErr_Occurred check outside
+            }
+            return false; // we have a PyErr_Occurred check outside
+        }
+    };
+
+    inline bool __Pyx_libcpp_cv_dummy_predicate() { return true; }  // Just used for type deduction, not called
+
+    template <typename Lock, typename CV_T>
+    void __Pyx_libcpp_cv_py_safe_wait_2arg(CV_T& cv, Lock& lock) {
+        __Pyx_UnknownThreadState ts = __Pyx_SaveUnknownThread();
+        auto cleanup = __pyx_make_libcpp_mutex_cleanup_on_exit(
+            [&ts, &lock](){
+                __Pyx_libcpp_cv_relock_at_end(lock, ts);
+            }
+        );
+        cv.wait(lock);
+    }
+
+    template <typename Lock, typename Predicate, typename CV_T, typename ...Args>
+    auto __Pyx_libcpp_cv_py_safe_wait_impl(CV_T& cv, Lock& lock, Predicate pred, Args&&... args)
+        -> decltype(cv.wait(lock, std::forward<Args>(args)..., __Pyx_libcpp_cv_dummy_predicate)) {
+        __Pyx_UnknownThreadState ts = __Pyx_SaveUnknownThread();
+        auto cleanup = __pyx_make_libcpp_mutex_cleanup_on_exit(
+            [&ts, &lock](){
+                __Pyx_libcpp_cv_relock_at_end(lock, ts);
+            });
+        return cv.wait(lock, std::forward<Args>(args)..., __Pyx_libcpp_cv_py_safe_wrap_predicate(&lock, &pred, &ts));
+    }
+
+    template <typename Predicate, typename Lock, typename CV>
+    void __Pyx_libcpp_cv_py_safe_wait_3arg(CV& cv, Lock& lock, Predicate predicate) {
+        return __Pyx_libcpp_cv_py_safe_wait_impl(cv, lock, std::move(predicate));
+    }
+
+    // StopToken only templated not break c++11 (where std::stop_token doesn't yet exist)
+    template <typename Lock, typename Predicate, typename StopToken>
+    bool __Pyx_libcpp_cv_py_safe_wait_4arg(std::condition_variable_any& cv, Lock& lock, StopToken stoken, Predicate pred) {
+        // note in impl, predicate comes first
+        return __Pyx_libcpp_cv_py_safe_wait_impl(cv, lock, std::move(pred), std::move(stoken));
+    }
+
+    template <typename Lock, typename CV_T>
+    void __Pyx_libcpp_cv_py_safe_wait_object3(CV_T& cv, Lock& lock, PyObject *pred) {
+        __Pyx_libcpp_cv_py_safe_wait_impl(
+            cv, lock,
+            __Pyx_libcpp_cv_WrappedPyObjectPredicate(pred));
+    }
+
+    template <typename Lock, typename CV_T, typename StopToken>
+    bool __Pyx_libcpp_cv_py_safe_wait_object4(CV_T& cv, Lock& lock, StopToken st, PyObject *pred) {
+        return __Pyx_libcpp_cv_py_safe_wait_impl(
+            cv, lock,
+            __Pyx_libcpp_cv_WrappedPyObjectPredicate(pred),
+            std::move(st));
+    }
+
+    template <typename Duration, typename Lock, typename CV_T>
+    std::cv_status __Pyx_libcpp_cv_py_safe_wait_for_3arg(CV_T& cv, Lock& lock, const Duration& duration) {
+        __Pyx_UnknownThreadState ts = __Pyx_SaveUnknownThread();
+        auto cleanup = __pyx_make_libcpp_mutex_cleanup_on_exit(
+            [&ts, &lock](){
+                __Pyx_libcpp_cv_relock_at_end(lock, ts);
+            }
+        );
+        return cv.wait_for(lock, duration);
+    }
+
+    template <typename Duration, typename Lock, typename Predicate, typename CV_T, typename ...Args>
+    bool __Pyx_libcpp_cv_py_safe_wait_for_impl(CV_T& cv, Lock& lock, const Duration &duration, Predicate pred, Args&&... args) {
+        __Pyx_UnknownThreadState ts = __Pyx_SaveUnknownThread();
+        auto cleanup = __pyx_make_libcpp_mutex_cleanup_on_exit(
+            [&ts, &lock](){
+                __Pyx_libcpp_cv_relock_at_end(lock, ts);
+            });
+        return cv.wait_for(lock, std::forward<Args>(args)..., duration, __Pyx_libcpp_cv_py_safe_wrap_predicate(&lock, &pred, &ts));
+    }
+
+    template <typename Duration, typename Predicate, typename Lock, typename CV>
+    bool __Pyx_libcpp_cv_py_safe_wait_for_4arg(CV& cv, Lock& lock, const Duration& duration, Predicate predicate) {
+        return __Pyx_libcpp_cv_py_safe_wait_for_impl(cv, lock, duration, std::move(predicate));
+    }
+
+    template <typename Duration, typename Predicate, typename Lock, typename CV, typename StopToken>
+    bool __Pyx_libcpp_cv_py_safe_wait_for_5arg(CV& cv, Lock& lock, StopToken stop_token, const Duration& duration, Predicate predicate) {
+        return __Pyx_libcpp_cv_py_safe_wait_for_impl(cv, lock, duration, std::move(predicate), std::move(stop_token));
+    }
+
+    template <typename Duration, typename Lock, typename CV_T>
+    bool __Pyx_libcpp_cv_py_safe_wait_for_object4(CV_T& cv, Lock& lock, const Duration& duration, PyObject *pred) {
+        return __Pyx_libcpp_cv_py_safe_wait_for_impl(
+            cv, lock, duration,
+            __Pyx_libcpp_cv_WrappedPyObjectPredicate(pred));
+    }
+
+    template <typename Duration, typename Lock, typename CV_T, typename StopToken>
+    bool __Pyx_libcpp_cv_py_safe_wait_for_object5(CV_T& cv, Lock& lock, StopToken st, const Duration& duration, PyObject *pred) {
+        return __Pyx_libcpp_cv_py_safe_wait_for_impl(
+            cv, lock, duration,
+            __Pyx_libcpp_cv_WrappedPyObjectPredicate(pred),
+            std::move(st));
+    }
+
+    template <typename Timepoint, typename Lock, typename CV_T>
+    std::cv_status __Pyx_libcpp_cv_py_safe_wait_until_3arg(CV_T& cv, Lock& lock, const Timepoint& timepoint) {
+        __Pyx_UnknownThreadState ts = __Pyx_SaveUnknownThread();
+        auto cleanup = __pyx_make_libcpp_mutex_cleanup_on_exit(
+            [&ts, &lock](){
+                __Pyx_libcpp_cv_relock_at_end(lock, ts);
+            }
+        );
+        return cv.wait_until(lock, timepoint);
+    }
+
+    template <typename Timepoint, typename Lock, typename Predicate, typename CV_T, typename ...Args>
+    bool __Pyx_libcpp_cv_py_safe_wait_until_impl(CV_T& cv, Lock& lock, const Timepoint &timepoint, Predicate pred, Args&&... args) {
+        __Pyx_UnknownThreadState ts = __Pyx_SaveUnknownThread();
+        auto cleanup = __pyx_make_libcpp_mutex_cleanup_on_exit(
+            [&ts, &lock](){
+                __Pyx_libcpp_cv_relock_at_end(lock, ts);
+            });
+        return cv.wait_until(lock, std::forward<Args>(args)..., timepoint, __Pyx_libcpp_cv_py_safe_wrap_predicate(&lock, &pred, &ts));
+    }
+
+    template <typename Timepoint, typename Predicate, typename Lock, typename CV>
+    bool __Pyx_libcpp_cv_py_safe_wait_until_4arg(CV& cv, Lock& lock, const Timepoint& timepoint, Predicate predicate) {
+        return __Pyx_libcpp_cv_py_safe_wait_until_impl(cv, lock, timepoint, std::move(predicate));
+    }
+
+    template <typename Timepoint, typename Predicate, typename Lock, typename CV, typename StopToken>
+    bool __Pyx_libcpp_cv_py_safe_wait_until_5arg(CV& cv, Lock& lock, StopToken stop_token, const Timepoint& timepoint, Predicate predicate) {
+        return __Pyx_libcpp_cv_py_safe_wait_until_impl(cv, lock, timepoint, std::move(predicate), std::move(stop_token));
+    }
+
+    template <typename Timepoint, typename Lock, typename CV_T>
+    bool __Pyx_libcpp_cv_py_safe_wait_until_object4(CV_T& cv, Lock& lock, const Timepoint& timepoint, PyObject *pred) {
+        return __Pyx_libcpp_cv_py_safe_wait_until_impl(
+            cv, lock, timepoint,
+            __Pyx_libcpp_cv_WrappedPyObjectPredicate(pred));
+    }
+
+    template <typename Timepoint, typename Lock, typename CV_T, typename StopToken>
+    bool __Pyx_libcpp_cv_py_safe_wait_until_object5(CV_T& cv, Lock& lock, StopToken st, const Timepoint& timepoint, PyObject *pred) {
+        return __Pyx_libcpp_cv_py_safe_wait_until_impl(
+            cv, lock, timepoint,
+            __Pyx_libcpp_cv_WrappedPyObjectPredicate(pred),
+            std::move(st));
+    }
+
+    } // namespace
+    """
+    # py_safe functions:
+    # * Release the GIL when blocking
+    # * Restore the GIL to whatever state it was when called (without deadlock)
+    # * Hold the GIL while evaluating the predicate (without deadlock)
+    # * Can accept a Python object callable predicate
+    # The condition_variable_any versions require a lockable class that implements try_lock in addition to lock and unlock
+    #
+    void py_safe_wait "__Pyx_libcpp_cv_py_safe_wait_2arg" (condition_variable& cv, unique_lock[mutex]& lock) except+ nogil
+    void py_safe_object_wait "__Pyx_libcpp_cv_py_safe_wait_object3" (condition_variable& cv, unique_lock[mutex]& lock, object predicate) except+
+    void py_safe_wait "__Pyx_libcpp_cv_py_safe_wait_3arg" [Predicate](condition_variable& cv, unique_lock[mutex]& lock, Predicate predicate) except+ nogil
+    void py_safe_wait "__Pyx_libcpp_cv_py_safe_wait_2arg" [Lock](condition_variable_any& cv, Lock& lock) except+ nogil
+    void py_safe_object_wait "__Pyx_libcpp_cv_py_safe_wait_object3" [Lock](condition_variable_any& cv, Lock& lock, object predicate) except+
+    void py_safe_wait "__Pyx_libcpp_cv_py_safe_wait_3arg" [Predicate, Lock](condition_variable_any& cv, Lock& lock, Predicate predicate) except+ nogil
+    _bool py_safe_object_wait "__Pyx_libcpp_cv_py_safe_wait_object4" [Lock](condition_variable_any& cv, Lock& lock, stop_token stoken, object predicate) except+
+    _bool py_safe_wait "__Pyx_libcpp_cv_py_safe_wait_4arg" [Lock, Predicate](condition_variable_any& cv, Lock& lock, stop_token stoken, Predicate predicate) except+ nogil
+
+    cv_status py_safe_wait_for "__Pyx_libcpp_cv_py_safe_wait_for_3arg" [Duration](condition_variable& cv, unique_lock[mutex]& lock, const Duration &duration) except+ nogil
+    _bool py_safe_object_wait_for "__Pyx_libcpp_cv_py_safe_wait_for_object4" [Duration](condition_variable& cv, unique_lock[mutex]& lock, const Duration &duration, object pred) except+
+    _bool py_safe_wait_for "__Pyx_libcpp_cv_py_safe_wait_for_4arg" [Duration, Predicate](condition_variable& cv, unique_lock[mutex]& lock, const Duration &duration, Predicate pred) except+ nogil
+    cv_status py_safe_wait_for "__Pyx_libcpp_cv_py_safe_wait_for_3arg" [Duration, Lock](condition_variable_any& cv, Lock& lock, const Duration &duration) except+ nogil
+    _bool py_safe_object_wait_for "__Pyx_libcpp_cv_py_safe_wait_for_object4" [Duration, Lock](condition_variable_any& cv, Lock& lock, const Duration &duration, object pred) except+
+    _bool py_safe_wait_for "__Pyx_libcpp_cv_py_safe_wait_for_4arg" [Duration, Predicate, Lock](condition_variable_any& cv, Lock& lock, const Duration &duration, Predicate pred) except+ nogil
+    _bool py_safe_object_wait_for "__Pyx_libcpp_cv_py_safe_wait_for_object5" [Duration, Lock](condition_variable_any& cv, Lock& lock, stop_token stoken, const Duration &duration, object pred) except+
+    _bool py_safe_wait_for "__Pyx_libcpp_cv_py_safe_wait_for_5arg" [Duration, Predicate, Lock](condition_variable_any& cv, Lock& lock, stop_token stoken, const Duration &duration, Predicate pred) except+ nogil
+
+    cv_status py_safe_wait_until "__Pyx_libcpp_cv_py_safe_wait_until_3arg" [Timepoint](condition_variable& cv, unique_lock[mutex]& lock, const Timepoint &timepoint) except+ nogil
+    _bool py_safe_object_wait_until "__Pyx_libcpp_cv_py_safe_wait_until_object4" [Timepoint](condition_variable& cv, unique_lock[mutex]& lock, const Timepoint &timepoint, object pred) except+
+    _bool py_safe_wait_until "__Pyx_libcpp_cv_py_safe_wait_until_4arg" [Timepoint, Predicate](condition_variable& cv, unique_lock[mutex]& lock, const Timepoint &timepoint, Predicate pred) except+ nogil
+    cv_status py_safe_wait_until "__Pyx_libcpp_cv_py_safe_wait_until_3arg" [Timepoint, Lock](condition_variable_any& cv, Lock& lock, const Timepoint &timepoint) except+ nogil
+    _bool py_safe_object_wait_until "__Pyx_libcpp_cv_py_safe_wait_until_object4" [Timepoint, Lock](condition_variable_any& cv, Lock& lock, const Timepoint &timepoint, object pred) except+
+    _bool py_safe_wait_until "__Pyx_libcpp_cv_py_safe_wait_until_4arg" [Timepoint, Predicate, Lock](condition_variable_any& cv, Lock& lock, const Timepoint &timepoint, Predicate pred) except+ nogil
+    _bool py_safe_object_wait_until "__Pyx_libcpp_cv_py_safe_wait_until_object5" [Timepoint, Lock](condition_variable_any& cv, Lock& lock, stop_token stoken, const Timepoint &timepoint, object pred) except+
+    _bool py_safe_wait_until "__Pyx_libcpp_cv_py_safe_wait_until_5arg" [Timepoint, Predicate, Lock](condition_variable_any& cv, Lock& lock, stop_token stoken, const Timepoint &timepoint, Predicate pred) except+ nogil

Cython/Includes/libcpp/deque.pxd

@@ -0,0 +1,165 @@
+cdef extern from "<deque>" namespace "std" nogil:
+    cdef cppclass deque[T,ALLOCATOR=*]:
+        ctypedef T value_type
+        ctypedef ALLOCATOR allocator_type
+
+        # these should really be allocator_type.size_type and
+        # allocator_type.difference_type to be true to the C++ definition
+        # but cython doesn't support deferred access on template arguments
+        ctypedef size_t size_type
+        ctypedef ptrdiff_t difference_type
+
+        cppclass const_iterator
+        cppclass iterator:
+            iterator() except +
+            iterator(iterator&) except +
+            value_type& operator*()
+            iterator operator++()
+            iterator operator--()
+            iterator operator++(int)
+            iterator operator--(int)
+            iterator operator+(size_type)
+            iterator operator-(size_type)
+            difference_type operator-(iterator)
+            difference_type operator-(const_iterator)
+            bint operator==(iterator)
+            bint operator==(const_iterator)
+            bint operator!=(iterator)
+            bint operator!=(const_iterator)
+            bint operator<(iterator)
+            bint operator<(const_iterator)
+            bint operator>(iterator)
+            bint operator>(const_iterator)
+            bint operator<=(iterator)
+            bint operator<=(const_iterator)
+            bint operator>=(iterator)
+            bint operator>=(const_iterator)
+        cppclass const_iterator:
+            const_iterator() except +
+            const_iterator(iterator&) except +
+            const_iterator(const_iterator&) except +
+            operator=(iterator&) except +
+            const value_type& operator*()
+            const_iterator operator++()
+            const_iterator operator--()
+            const_iterator operator++(int)
+            const_iterator operator--(int)
+            const_iterator operator+(size_type)
+            const_iterator operator-(size_type)
+            difference_type operator-(iterator)
+            difference_type operator-(const_iterator)
+            bint operator==(iterator)
+            bint operator==(const_iterator)
+            bint operator!=(iterator)
+            bint operator!=(const_iterator)
+            bint operator<(iterator)
+            bint operator<(const_iterator)
+            bint operator>(iterator)
+            bint operator>(const_iterator)
+            bint operator<=(iterator)
+            bint operator<=(const_iterator)
+            bint operator>=(iterator)
+            bint operator>=(const_iterator)
+
+        cppclass const_reverse_iterator
+        cppclass reverse_iterator:
+            reverse_iterator() except +
+            reverse_iterator(reverse_iterator&) except +
+            value_type& operator*()
+            reverse_iterator operator++()
+            reverse_iterator operator--()
+            reverse_iterator operator++(int)
+            reverse_iterator operator--(int)
+            reverse_iterator operator+(size_type)
+            reverse_iterator operator-(size_type)
+            difference_type operator-(iterator)
+            difference_type operator-(const_iterator)
+            bint operator==(reverse_iterator)
+            bint operator==(const_reverse_iterator)
+            bint operator!=(reverse_iterator)
+            bint operator!=(const_reverse_iterator)
+            bint operator<(reverse_iterator)
+            bint operator<(const_reverse_iterator)
+            bint operator>(reverse_iterator)
+            bint operator>(const_reverse_iterator)
+            bint operator<=(reverse_iterator)
+            bint operator<=(const_reverse_iterator)
+            bint operator>=(reverse_iterator)
+            bint operator>=(const_reverse_iterator)
+        cppclass const_reverse_iterator:
+            const_reverse_iterator() except +
+            const_reverse_iterator(reverse_iterator&) except +
+            operator=(reverse_iterator&) except +
+            const value_type& operator*()
+            const_reverse_iterator operator++()
+            const_reverse_iterator operator--()
+            const_reverse_iterator operator++(int)
+            const_reverse_iterator operator--(int)
+            const_reverse_iterator operator+(size_type)
+            const_reverse_iterator operator-(size_type)
+            difference_type operator-(iterator)
+            difference_type operator-(const_iterator)
+            bint operator==(reverse_iterator)
+            bint operator==(const_reverse_iterator)
+            bint operator!=(reverse_iterator)
+            bint operator!=(const_reverse_iterator)
+            bint operator<(reverse_iterator)
+            bint operator<(const_reverse_iterator)
+            bint operator>(reverse_iterator)
+            bint operator>(const_reverse_iterator)
+            bint operator<=(reverse_iterator)
+            bint operator<=(const_reverse_iterator)
+            bint operator>=(reverse_iterator)
+            bint operator>=(const_reverse_iterator)
+
+        deque() except +
+        deque(deque&) except +
+        deque(size_t) except +
+        deque(size_t, T&) except +
+        #deque[InputIt](InputIt, InputIt)
+        T& operator[](size_t)
+        #deque& operator=(deque&)
+        bint operator==(deque&, deque&)
+        bint operator!=(deque&, deque&)
+        bint operator<(deque&, deque&)
+        bint operator>(deque&, deque&)
+        bint operator<=(deque&, deque&)
+        bint operator>=(deque&, deque&)
+        void assign(size_t, T&) except +
+        void assign[InputIt](InputIt, InputIt) except +
+        T& at(size_t) except +
+        T& back()
+        iterator begin()
+        const_iterator const_begin "begin"()
+        const_iterator cbegin()
+        void clear()
+        bint empty()
+        iterator end()
+        const_iterator const_end "end"()
+        const_iterator cend()
+        iterator erase(iterator) except +
+        iterator erase(iterator, iterator) except +
+        T& front()
+        iterator insert(iterator, T&) except +
+        void insert(iterator, size_t, T&) except +
+        void insert[InputIt](iterator, InputIt, InputIt) except +
+        size_t max_size()
+        void pop_back()
+        void pop_front()
+        void push_back(T&) except +
+        void push_front(T&) except +
+        reverse_iterator rbegin()
+        #const_reverse_iterator rbegin()
+        const_reverse_iterator crbegin()
+        reverse_iterator rend()
+        #const_reverse_iterator rend()
+        const_reverse_iterator crend()
+        void resize(size_t) except +
+        void resize(size_t, T&) except +
+        size_t size()
+        void swap(deque&)
+
+        # C++11 methods
+        void shrink_to_fit() except +
+        T& emplace_front(...) except +
+        T& emplace_back(...) except +

Cython/Includes/libcpp/exception.pxd

@@ -0,0 +1,86 @@
+from libcpp cimport bool
+
+cdef extern from "<exception>" namespace "std" nogil:
+    cdef cppclass exception_ptr:
+        bool operator bool()
+
+    exception_ptr make_exception_ptr[E](E e) noexcept
+    void rethrow_exception(exception_ptr) except +
+    # current_exception skipped because it'll be almost impossible to use from Cython
+
+cdef extern from *:
+    """
+    static void __Pyx_CppExn2PyErr(void);
+
+    CYTHON_UNUSED static void __pyx_deallocate_exception_ptr_capsule(PyObject *c) {
+        std::exception_ptr *ptr = static_cast<std::exception_ptr*>(
+            PyCapsule_GetPointer(c, "std::exception_ptr wrapper"));
+        delete ptr;
+        PyErr_Clear();
+    }
+
+    CYTHON_UNUSED static void __pyx_to_exception_ptr() {
+        try {
+            __Pyx_CppExn2PyErr(); // First do regular exception conversion
+            throw;
+        } catch (...) {
+            PyObject *type, *value, *tb;
+            PyErr_Fetch(&type, &value, &tb);
+            Py_XDECREF(value);
+            Py_XDECREF(tb);
+            std::exception_ptr *current = new std::exception_ptr(std::current_exception());
+            PyObject *capsule = PyCapsule_New(
+                static_cast<void*>(current),
+                "std::exception_ptr wrapper",
+                &__pyx_deallocate_exception_ptr_capsule);
+            if (!capsule)
+                delete current;  // otherwise it'll be leaked
+            else
+                PyErr_SetObject(type ? type : PyExc_Exception, capsule);
+            Py_DECREF(type);
+        }
+    }
+
+    CYTHON_UNUSED static std::exception_ptr __pyx_wrapped_exception_ptr_from_exception(PyObject *e) {
+        PyObject *args = NULL, *arg0 = NULL;
+        std::exception_ptr result;
+        Py_ssize_t size;
+#if __PYX_LIMITED_VERSION_HEX < 0x030C0000
+        args = PyObject_GetAttrString(e, "args");
+#else
+        args = PyException_GetArgs(e);
+#endif
+        if (!args)
+            goto done;
+        size = PyTuple_Size(args);
+        if (size != 1) {
+            if (size != -1)
+                PyErr_SetString(PyExc_ValueError, "exception args were not the expected length of 1");
+            goto done;
+        }
+        arg0 = PyTuple_GetItem(args, 0);
+        if (!arg0)
+            goto done;
+        {
+            std::exception_ptr* wrapped = static_cast<std::exception_ptr*>(
+                PyCapsule_GetPointer(arg0, "std::exception_ptr wrapper"));
+            if (!wrapped) {
+                goto done;
+            }
+            result = *wrapped;
+        }
+
+      done:
+        Py_XDECREF(args);
+        return result;
+    }
+    """
+    # This can be used as `except +exception_ptr_error_handler`.
+    # It raises a generic Exception, with a wrapped exception_ptr as its value.
+    void exception_ptr_error_handler "__pyx_to_exception_ptr"() except *
+    # Extract the exception_ptr from a caught exception
+    exception_ptr wrapped_exception_ptr_from_exception "__pyx_wrapped_exception_ptr_from_exception"(e) except *
+
+# Dummy inline function to force __Pyx_CppExn2PyErr to be included for utility code above
+cdef inline void __pyx_call_rethrow_exception "__pyx_call_rethrow_exception"(exception_ptr e) except*:
+    rethrow_exception(e)

Cython/Includes/libcpp/execution.pxd

@@ -0,0 +1,15 @@
+
+cdef extern from "<execution>" namespace "std::execution" nogil:
+    cdef cppclass sequenced_policy:
+        pass
+    cdef cppclass parallel_policy:
+        pass
+    cdef cppclass parallel_unsequenced_policy:
+        pass
+    cdef cppclass unsequenced_policy:
+        pass
+
+    const sequenced_policy seq "std::execution::seq"
+    const parallel_policy par "std::execution::par"
+    const parallel_unsequenced_policy par_unseq "std::execution::par_unseq"
+    const unsequenced_policy unseq "std::execution::unseq"

Cython/Includes/libcpp/forward_list.pxd

@@ -0,0 +1,63 @@
+cdef extern from "<forward_list>" namespace "std" nogil:
+    cdef cppclass forward_list[T,ALLOCATOR=*]:
+        ctypedef T value_type
+        ctypedef ALLOCATOR allocator_type
+
+        # these should really be allocator_type.size_type and
+        # allocator_type.difference_type to be true to the C++ definition
+        # but cython doesn't support deferred access on template arguments
+        ctypedef size_t size_type
+        ctypedef ptrdiff_t difference_type
+
+        cppclass iterator:
+            iterator()
+            iterator(iterator &)
+            T& operator*()
+            iterator operator++()
+            iterator operator++(int)
+            bint operator==(iterator)
+            bint operator!=(iterator)
+        cppclass const_iterator(iterator):
+            pass
+        forward_list() except +
+        forward_list(forward_list&) except +
+        forward_list(size_t, T&) except +
+        #forward_list& operator=(forward_list&)
+        bint operator==(forward_list&, forward_list&)
+        bint operator!=(forward_list&, forward_list&)
+        bint operator<(forward_list&, forward_list&)
+        bint operator>(forward_list&, forward_list&)
+        bint operator<=(forward_list&, forward_list&)
+        bint operator>=(forward_list&, forward_list&)
+        void assign(size_t, T&)
+        T& front()
+        iterator before_begin()
+        const_iterator const_before_begin "before_begin"()
+        iterator begin()
+        const_iterator const_begin "begin"()
+        iterator end()
+        const_iterator const_end "end"()
+        bint empty()
+        size_t max_size()
+        void clear()
+        iterator insert_after(iterator, T&)
+        void insert_after(iterator, size_t, T&)
+        iterator erase_after(iterator)
+        iterator erase_after(iterator, iterator)
+        void push_front(T&)
+        void pop_front()
+        void resize(size_t)
+        void resize(size_t, T&)
+        void swap(forward_list&)
+        void merge(forward_list&)
+        void merge[Compare](forward_list&, Compare)
+        void splice_after(iterator, forward_list&)
+        void splice_after(iterator, forward_list&, iterator)
+        void splice_after(iterator, forward_list&, iterator, iterator)
+        void remove(const T&)
+        void remove_if[Predicate](Predicate)
+        void reverse()
+        void unique()
+        void unique[Predicate](Predicate)
+        void sort()
+        void sort[Compare](Compare)

Cython/Includes/libcpp/functional.pxd

@@ -0,0 +1,26 @@
+from libcpp cimport bool
+
+cdef extern from "<functional>" namespace "std" nogil:
+    cdef cppclass function[T]:
+        function() except +
+        function(T*) except +
+        function(function&) except +
+        function(void*) except +
+
+        function operator=(T*)
+        function operator=(function&)
+        function operator=(void*)
+        function operator=[U](U)
+
+        bool operator bool()
+
+    # Comparisons
+    cdef cppclass greater[T=*]:
+        # https://github.com/cython/cython/issues/3193
+        greater() except +
+        bool operator()(const T& lhs, const T& rhs) except +
+
+    cdef cppclass reference_wrapper[T]:
+        reference_wrapper()
+        reference_wrapper(T)
+        T& get() const