Cython 3.2.0__cp39-abi3-win32.whl

Cython/Includes/libcpp/future.pxd

@@ -0,0 +1,103 @@
+from libcpp cimport bool
+from libcpp.exception cimport exception_ptr
+
+cdef extern from "<future>":
+    pass  # include first
+
+cdef extern from *:
+    """
+    static void __Pyx_CppExn2PyErr();
+    CYTHON_UNUSED static void __pyx_future_error_handler() {
+        try {
+            throw;
+        } catch (const std::future_error &e) {
+            PyObject *args = Py_BuildValue(
+                "sis",
+                "std::future_error",
+                e.code().value(),
+                e.what()
+            );
+            if (!args) return;
+            Py_INCREF(PyExc_RuntimeError);
+            // It'd be nice to raise something more specific, but I can't easily do that
+            // so I've tried to at least make them identifiable by the arguments.
+            PyErr_Restore(PyExc_RuntimeError, args, NULL);
+        } catch (...) {
+            // Forward to the normal Cython exception conversion;
+            __Pyx_CppExn2PyErr();
+        }
+    }
+    """
+    void __pyx_future_error_handler() except+
+
+cdef extern from "<future>" namespace "std" nogil:
+    cdef enum class future_status:
+        ready
+        timeout
+        deferred
+
+    cdef cppclass future[T]:
+        future() noexcept
+        future(future& other) noexcept  # slightly mistyped move constructor
+
+        future& operator=(future& other) noexcept  # slightly mistyped move assignment
+
+        shared_future[T] share() noexcept
+
+        # Not strictly right when T is a reference or void
+        T get() except +__pyx_future_error_handler
+
+        bool valid() noexcept
+
+        void wait() except+
+        # For wait_for and wait_until we don't have chrono yet
+        future_status wait_for(...) except+
+        future_status wait_until(...) except+
+
+    cdef cppclass shared_future[T]:
+        shared_future() noexcept
+        shared_future(const shared_future& other) noexcept  # noexcept only from c++17 strictly
+        shared_future(future[T]& other) noexcept  # slightly mistyped move
+
+        shared_future& operator=(const shared_future& other) noexcept  # noexcept only from c++17 strictly
+        shared_future& operator=(future& other) noexcept  # slightly mistyped move
+
+        # Not strictly right when T is a reference or void
+        const T& get() except +__pyx_future_error_handler
+
+        bool valid() noexcept
+
+        void wait() except+
+        # For wait_for and wait_until we don't have chrono yet
+        future_status wait_for(...) except+
+        future_status wait_until(...) except+
+
+    cdef cppclass promise[T]:
+        promise() noexcept
+        # don't expose the allocator version
+        promise(promise& other) noexcept  # slightly mistyped move
+
+        promise& operator=(promise& other) noexcept  # slightly mistyped move
+
+        void swap(promise& other) noexcept
+
+        future[T] get_future() except+
+
+        # Note that the set_* functions all have specialized error handling.
+        # A std::future_error will be converted to a RuntimeError with 3 arguments.
+        # The first argument is the string "std::future_error",
+        # the second is the error code as an int for comparison with future_errc,
+        # and the third is the message.
+        void set_value(T value) except +__pyx_future_error_handler
+        void set_value() except +__pyx_future_error_handler  # only for void specialization
+        void set_value_at_thread_exit(T value) except +__pyx_future_error_handler
+        void set_value_at_thread_exit() except +__pyx_future_error_handler  # only for void specialization
+
+        void set_exception(exception_ptr p) except +__pyx_future_error_handler
+        void set_exception_at_thread_exit(exception_ptr p) except +__pyx_future_error_handler
+
+    cdef enum class future_errc:
+        broken_promise
+        future_already_retrieved
+        promise_already_satisfied
+        no_state

Cython/Includes/libcpp/iterator.pxd

@@ -0,0 +1,34 @@
+#Basic reference: http://www.cplusplus.com/reference/iterator/
+#Most of these classes are in fact empty structs
+
+from libc.stddef import ptrdiff_t
+
+cdef extern from "<iterator>" namespace "std" nogil:
+    cdef cppclass iterator[Category,T,Distance,Pointer,Reference]:
+        pass
+    cdef cppclass output_iterator_tag:
+        pass
+    cdef cppclass input_iterator_tag:
+        pass
+    cdef cppclass forward_iterator_tag(input_iterator_tag):
+        pass
+    cdef cppclass bidirectional_iterator_tag(forward_iterator_tag):
+        pass
+    cdef cppclass random_access_iterator_tag(bidirectional_iterator_tag):
+        pass
+
+    cdef cppclass back_insert_iterator[T](iterator[output_iterator_tag,void,void,void,void]):
+        pass
+    cdef cppclass front_insert_iterator[T](iterator[output_iterator_tag,void,void,void,void]):
+        pass
+    cdef cppclass insert_iterator[T](iterator[output_iterator_tag,void,void,void,void]):
+        pass
+    back_insert_iterator[CONTAINER] back_inserter[CONTAINER](CONTAINER &)
+    front_insert_iterator[CONTAINER] front_inserter[CONTAINER](CONTAINER &)
+    ##Note: this is the C++98 version of inserter.
+    ##The C++11 versions's prototype relies on typedef members of classes, which Cython doesn't currently support:
+    ##template <class Container>
+    ##insert_iterator<Container> inserter (Container& x, typename Container::iterator it)
+    insert_iterator[CONTAINER] inserter[CONTAINER,ITERATOR](CONTAINER &, ITERATOR)
+
+    ptrdiff_t distance[It](It first, It last)

Cython/Includes/libcpp/latch.pxd

@@ -0,0 +1,17 @@
+from libcpp cimport bool
+
+cdef extern from "<latch>" namespace "std" nogil:
+    # Note on thread safety:
+    # For any of the blocking functions, you should be very careful
+    # to ensure that you are not deadlocked on the GIL.
+    cdef cppclass latch:
+        latch(ptrdiff_t expected)
+
+        void count_down() except+
+        void count_down(ptrdiff_t n) except+
+        bool try_wait()
+        void wait() except+
+        void arrive_and_wait() except+
+        void arrive_and_wait(ptrdiff_t n) except+
+
+        ptrdiff_t max()

Cython/Includes/libcpp/limits.pxd

@@ -0,0 +1,61 @@
+cdef extern from "<limits>" namespace "std" nogil:
+    enum float_round_style:
+        round_indeterminate       = -1
+        round_toward_zero         = 0
+        round_to_nearest          = 1
+        round_toward_infinity     = 2
+        round_toward_neg_infinity = 3
+
+    enum float_denorm_style:
+        denorm_indeterminate  = -1
+        denorm_absent         = 0
+        denorm_present        = 1
+
+    #The static methods can be called as, e.g. numeric_limits[int].round_error(), etc.
+    #The const data members should be declared as static.  Cython currently doesn't allow that
+    #and/or I can't figure it out, so you must instantiate an object to access, e.g.
+    #cdef numeric_limits[double] lm
+    #print lm.round_style
+    cdef cppclass numeric_limits[T]:
+        const bint is_specialized
+        @staticmethod
+        T min()
+        @staticmethod
+        T max()
+        const int digits
+        const int  digits10
+        const bint is_signed
+        const bint is_integer
+        const bint is_exact
+        const int radix
+        @staticmethod
+        T epsilon()
+        @staticmethod
+        T round_error()
+
+        const int  min_exponent
+        const int  min_exponent10
+        const int  max_exponent
+        const int  max_exponent10
+
+        const bint has_infinity
+        const bint has_quiet_NaN
+        const bint has_signaling_NaN
+        const float_denorm_style has_denorm
+        const bint has_denorm_loss
+        @staticmethod
+        T infinity()
+        @staticmethod
+        T quiet_NaN()
+        @staticmethod
+        T signaling_NaN()
+        @staticmethod
+        T denorm_min()
+
+        const bint is_iec559
+        const bint is_bounded
+        const bint is_modulo
+
+        const bint traps
+        const bint tinyness_before
+        const float_round_style round_style

Cython/Includes/libcpp/list.pxd

@@ -0,0 +1,117 @@
+cdef extern from "<list>" namespace "std" nogil:
+    cdef cppclass 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 const_iterator
+        cppclass iterator:
+            iterator() except +
+            iterator(iterator&) except +
+            value_type& operator*()
+            iterator operator++()
+            iterator operator--()
+            iterator operator++(int)
+            iterator operator--(int)
+            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)
+            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)
+            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)
+            bint operator==(reverse_iterator)
+            bint operator==(const_reverse_iterator)
+            bint operator!=(reverse_iterator)
+            bint operator!=(const_reverse_iterator)
+
+        list() except +
+        list(list&) except +
+        list(size_t, T&) except +
+        #list operator=(list&)
+        bint operator==(list&, list&)
+        bint operator!=(list&, list&)
+        bint operator<(list&, list&)
+        bint operator>(list&, list&)
+        bint operator<=(list&, list&)
+        bint operator>=(list&, list&)
+        void assign(size_t, 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)
+        iterator erase(iterator, iterator)
+        T& front()
+        iterator insert(iterator, T&)
+        void insert(iterator, size_t, T&)
+        size_t max_size()
+        void merge(list&) except +
+        #void merge(list&, BinPred)
+        void pop_back()
+        void pop_front()
+        void push_back(T&) except +
+        void push_front(T&) except +
+        reverse_iterator rbegin()
+        const_reverse_iterator const_rbegin "rbegin"()
+        const_reverse_iterator crbegin()
+        void remove(T&) except +
+        #void remove_if(UnPred)
+        reverse_iterator rend()
+        const_reverse_iterator const_rend "rend"()
+        const_reverse_iterator crend()
+        void resize(size_t, T&) except +
+        void reverse()
+        size_t size()
+        void sort() except +
+        #void sort(BinPred)
+        void splice(iterator, list&)
+        void splice(iterator, list&, iterator)
+        void splice(iterator, list&, iterator, iterator)
+        void swap(list&)
+        void unique()
+        #void unique(BinPred)

Cython/Includes/libcpp/map.pxd

@@ -0,0 +1,252 @@
+from .utility cimport pair
+
+cdef extern from "<map>" namespace "std" nogil:
+    cdef cppclass map[T, U, COMPARE=*, ALLOCATOR=*]:
+        ctypedef T key_type
+        ctypedef U mapped_type
+        ctypedef pair[const T, U] value_type
+        ctypedef COMPARE key_compare
+        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 +
+            # correct would be value_type& but this does not work
+            # well with cython's code gen
+            pair[T, U]& operator*()
+            iterator operator++()
+            iterator operator--()
+            iterator operator++(int)
+            iterator operator--(int)
+            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 +
+            # correct would be const value_type& but this does not work
+            # well with cython's code gen
+            const pair[T, U]& operator*()
+            const_iterator operator++()
+            const_iterator operator--()
+            const_iterator operator++(int)
+            const_iterator operator--(int)
+            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 +
+            # correct would be value_type& but this does not work
+            # well with cython's code gen
+            pair[T, U]& operator*()
+            reverse_iterator operator++()
+            reverse_iterator operator--()
+            reverse_iterator operator++(int)
+            reverse_iterator operator--(int)
+            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 +
+            # correct would be const value_type& but this does not work
+            # well with cython's code gen
+            const pair[T, U]& operator*()
+            const_reverse_iterator operator++()
+            const_reverse_iterator operator--()
+            const_reverse_iterator operator++(int)
+            const_reverse_iterator operator--(int)
+            bint operator==(reverse_iterator)
+            bint operator==(const_reverse_iterator)
+            bint operator!=(reverse_iterator)
+            bint operator!=(const_reverse_iterator)
+
+        map() except +
+        map(map&) except +
+        #map(key_compare&)
+        U& operator[](const T&)
+        #map& operator=(map&)
+        bint operator==(map&, map&)
+        bint operator!=(map&, map&)
+        bint operator<(map&, map&)
+        bint operator>(map&, map&)
+        bint operator<=(map&, map&)
+        bint operator>=(map&, map&)
+        U& at(const T&) except +
+        const U& const_at "at"(const T&) except +
+        iterator begin()
+        const_iterator const_begin "begin" ()
+        const_iterator cbegin()
+        void clear()
+        size_t count(const T&)
+        bint empty()
+        iterator end()
+        const_iterator const_end "end" ()
+        const_iterator cend()
+        pair[iterator, iterator] equal_range(const T&)
+        pair[const_iterator, const_iterator] const_equal_range "equal_range"(const T&)
+        iterator erase(iterator)
+        iterator const_erase "erase"(const_iterator)
+        iterator erase(const_iterator, const_iterator)
+        size_t erase(const T&)
+        iterator find(const T&)
+        const_iterator const_find "find" (const T&)
+        pair[iterator, bint] insert(const pair[T, U]&) except +
+        iterator insert(const_iterator, const pair[T, U]&) except +
+        void insert[InputIt](InputIt, InputIt) except +
+        #key_compare key_comp()
+        iterator lower_bound(const T&)
+        const_iterator const_lower_bound "lower_bound"(const T&)
+        size_t max_size()
+        reverse_iterator rbegin()
+        const_reverse_iterator const_rbegin "rbegin"()
+        const_reverse_iterator crbegin()
+        reverse_iterator rend()
+        const_reverse_iterator const_rend "rend"()
+        const_reverse_iterator crend()
+        size_t size()
+        void swap(map&)
+        iterator upper_bound(const T&)
+        const_iterator const_upper_bound "upper_bound"(const T&)
+        #value_compare value_comp()
+        # C++20
+        bint contains(const T&)
+
+    cdef cppclass multimap[T, U, COMPARE=*, ALLOCATOR=*]:
+        ctypedef T key_type
+        ctypedef U mapped_type
+        ctypedef pair[const T, U] value_type
+        ctypedef COMPARE key_compare
+        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 +
+            # correct would be value_type& but this does not work
+            # well with cython's code gen
+            pair[T, U]& operator*()
+            iterator operator++()
+            iterator operator--()
+            iterator operator++(int)
+            iterator operator--(int)
+            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 +
+            # correct would be const value_type& but this does not work
+            # well with cython's code gen
+            const pair[T, U]& operator*()
+            const_iterator operator++()
+            const_iterator operator--()
+            const_iterator operator++(int)
+            const_iterator operator--(int)
+            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 +
+            # correct would be value_type& but this does not work
+            # well with cython's code gen
+            pair[T, U]& operator*()
+            reverse_iterator operator++()
+            reverse_iterator operator--()
+            reverse_iterator operator++(int)
+            reverse_iterator operator--(int)
+            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 +
+            # correct would be const value_type& but this does not work
+            # well with cython's code gen
+            const pair[T, U]& operator*()
+            const_reverse_iterator operator++()
+            const_reverse_iterator operator--()
+            const_reverse_iterator operator++(int)
+            const_reverse_iterator operator--(int)
+            bint operator==(reverse_iterator)
+            bint operator==(const_reverse_iterator)
+            bint operator!=(reverse_iterator)
+            bint operator!=(const_reverse_iterator)
+
+        multimap() except +
+        multimap(const multimap&) except +
+        #multimap(key_compare&)
+        #multimap& operator=(multimap&)
+        bint operator==(const multimap&, const multimap&)
+        bint operator!=(const multimap&, const multimap&)
+        bint operator<(const multimap&, const multimap&)
+        bint operator>(const multimap&, const multimap&)
+        bint operator<=(const multimap&, const multimap&)
+        bint operator>=(const multimap&, const multimap&)
+        iterator begin()
+        const_iterator const_begin "begin"()
+        const_iterator cbegin()
+        void clear()
+        size_t count(const T&)
+        bint empty()
+        iterator end()
+        const_iterator const_end "end"()
+        const_iterator cend()
+        pair[iterator, iterator] equal_range(const T&)
+        pair[const_iterator, const_iterator] const_equal_range "equal_range"(const T&)
+        iterator erase(iterator)
+        iterator const_erase "erase"(const_iterator)
+        iterator erase(const_iterator, const_iterator)
+        size_t erase(const T&)
+        iterator find(const T&)
+        const_iterator const_find "find"(const T&)
+        iterator insert(const pair[T, U]&) except +
+        iterator insert(const_iterator, const pair[T, U]&) except +
+        void insert[InputIt](InputIt, InputIt) except +
+        #key_compare key_comp()
+        iterator lower_bound(const T&)
+        const_iterator const_lower_bound "lower_bound"(const T&)
+        size_t max_size()
+        reverse_iterator rbegin()
+        const_reverse_iterator const_rbegin "rbegin"()
+        const_reverse_iterator crbegin()
+        reverse_iterator rend()
+        const_reverse_iterator const_rend "rend"()
+        const_reverse_iterator crend()
+        size_t size()
+        void swap(multimap&)
+        iterator upper_bound(const T&)
+        const_iterator const_upper_bound "upper_bound"(const T&)
+        #value_compare value_comp()
+        bint contains(const T&)