Cython 3.1.0__py3-none-any.whl

Cython/Includes/libcpp/string_view.pxd

@@ -0,0 +1,181 @@
+from libcpp.string cimport string
+
+cdef extern from "<string_view>" namespace "std::string_view" nogil:
+    const size_t npos
+
+cdef extern from "<string_view>" namespace "std" nogil:
+
+    cdef cppclass string_view:
+        ctypedef char value_type
+        ctypedef size_t size_type
+        ctypedef ptrdiff_t difference_type
+
+        bint operator==(string_view)
+        bint operator!= (string_view)
+        bint operator< (string_view)
+        bint operator> (string_view)
+        bint operator<= (string_view)
+        bint operator>= (string_view)
+
+        cppclass const_iterator:
+            const_iterator()
+            const_iterator(const_iterator&)
+            operator=(const_iterator&)
+            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-(const_iterator)
+            bint operator==(const_iterator)
+            bint operator!=(const_iterator)
+            bint operator<(const_iterator)
+            bint operator>(const_iterator)
+            bint operator<=(const_iterator)
+            bint operator>=(const_iterator)
+
+        ctypedef const_iterator iterator
+
+        cppclass const_reverse_iterator:
+            const_reverse_iterator()
+            const_reverse_iterator(const_reverse_iterator&)
+            operator=(const_reverse_iterator&)
+            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-(const_reverse_iterator)
+            bint operator==(const_reverse_iterator)
+            bint operator!=(const_reverse_iterator)
+            bint operator<(const_reverse_iterator)
+            bint operator>(const_reverse_iterator)
+            bint operator<=(const_reverse_iterator)
+            bint operator>=(const_reverse_iterator)
+
+        ctypedef const_reverse_iterator reverse_iterator
+
+        # Constructors
+        string_view()  # (1)
+        string_view(string_view s)  # (2)
+        string_view(const char* s, size_t n)  # (3)
+        string_view(const char* s)  # (4)
+        string_view& string_view[InputIt](InputIt, InputIt)  # (5)
+
+        # This should be `operator string_view()` on std::string, but
+        # Cython doesn't yet allow declaring it.
+        string_view(const string&)
+
+        # Assignment
+        string_view& operator=(string_view)
+
+        # Iterators
+        const_iterator begin()
+        const_iterator end()
+        const_iterator cbegin()
+        const_iterator cend()
+
+        const_reverse_iterator rbegin()
+        const_reverse_iterator rend()
+        const_reverse_iterator crbegin()
+        const_reverse_iterator crend()
+
+        # Capacity
+        size_t size()
+        size_t length()
+        size_t max_size()
+        bint empty()
+
+        # Element access
+        const char& operator[](size_t pos)
+        const char& at(size_t pos) except +
+        const char& front()
+        const char& back()
+
+        const char* data()
+
+        # Modifiers
+        void remove_prefix(size_t n)
+        void remove_suffix(size_t n)
+        void swap(string_view& other)
+
+        # Operations
+        size_t copy(char* dest, size_t count, size_t pos)
+        size_t copy(char* dest, size_t count)
+
+        size_t find(string_view s, size_t pos)
+        size_t find(string_view s)
+        size_t find(const char* s, size_t pos, size_t n)
+        size_t find(const char* s, size_t pos)
+        size_t find(const char* s)
+        size_t find(char c, size_t pos)
+        size_t find(char c)
+
+        size_t rfind(string_view, size_t pos)
+        size_t rfind(string_view)
+        size_t rfind(const char* s, size_t pos, size_t n)
+        size_t rfind(const char* s, size_t pos)
+        size_t rfind(const char* s)
+        size_t rfind(char c, size_t pos)
+        size_t rfind(char c)
+
+        size_t find_first_of(string_view, size_t pos)
+        size_t find_first_of(string_view)
+        size_t find_first_of(const char* s, size_t pos, size_t n)
+        size_t find_first_of(const char* s, size_t pos)
+        size_t find_first_of(const char* s)
+        size_t find_first_of(char c, size_t pos)
+        size_t find_first_of(char c)
+
+        size_t find_first_not_of(string_view s, size_t pos)
+        size_t find_first_not_of(string_view s)
+        size_t find_first_not_of(const char* s, size_t pos, size_t n)
+        size_t find_first_not_of(const char* s, size_t pos)
+        size_t find_first_not_of(const char*)
+        size_t find_first_not_of(char c, size_t pos)
+        size_t find_first_not_of(char c)
+
+        size_t find_last_of(string_view s, size_t pos)
+        size_t find_last_of(string_view s)
+        size_t find_last_of(const char* s, size_t pos, size_t n)
+        size_t find_last_of(const char* s, size_t pos)
+        size_t find_last_of(const char* s)
+        size_t find_last_of(char c, size_t pos)
+        size_t find_last_of(char c)
+
+        size_t find_last_not_of(string_view s, size_t pos)
+        size_t find_last_not_of(string_view s)
+        size_t find_last_not_of(const char* s, size_t pos, size_t n)
+        size_t find_last_not_of(const char* s, size_t pos)
+        size_t find_last_not_of(const char* s)
+        size_t find_last_not_of(char c, size_t pos)
+        size_t find_last_not_of(char c)
+
+        string_view substr(size_t pos, size_t len) except +
+        string_view substr(size_t pos) except +
+        string_view substr()
+
+        int compare(string_view s)
+        int compare(size_t pos, size_t len, string_view s)
+        int compare(size_t pos, size_t len, string_view s, size_t subpos, size_t sublen)
+        int compare(const char* s)
+        int compare(size_t pos, size_t len, const char* s)
+        int compare(size_t pos, size_t len, const char* s , size_t n)
+
+        # C++20
+        bint starts_with(string_view s)
+        bint starts_with(char c)
+        bint starts_with(const char* s)
+
+        bint ends_with(string_view s)
+        bint ends_with(char c)
+        bint ends_with(const char* s)
+
+        # C++23
+        bint contains(string_view s)
+        bint contains(char c)
+        bint contains(const char* s)

Cython/Includes/libcpp/typeindex.pxd

@@ -0,0 +1,15 @@
+from libcpp cimport bool
+from .typeinfo cimport type_info
+
+# This class is C++11-only
+cdef extern from "<typeindex>" namespace "std" nogil:
+    cdef cppclass type_index:
+        type_index(const type_info &)
+        const char* name()
+        size_t hash_code()
+        bool operator==(const type_index &)
+        bool operator!=(const type_index &)
+        bool operator<(const type_index &)
+        bool operator<=(const type_index &)
+        bool operator>(const type_index &)
+        bool operator>=(const type_index &)

Cython/Includes/libcpp/typeinfo.pxd

@@ -0,0 +1,10 @@
+from libcpp cimport bool
+
+cdef extern from "<typeinfo>" namespace "std" nogil:
+    cdef cppclass type_info:
+        const char* name()
+        int before(const type_info&)
+        bool operator==(const type_info&)
+        bool operator!=(const type_info&)
+        # C++11-only
+        size_t hash_code()

Cython/Includes/libcpp/unordered_map.pxd

@@ -0,0 +1,193 @@
+from .utility cimport pair
+
+cdef extern from "<unordered_map>" namespace "std" nogil:
+    cdef cppclass unordered_map[T, U, HASH=*, PRED=*, ALLOCATOR=*]:
+        ctypedef T key_type
+        ctypedef U mapped_type
+        ctypedef pair[const T, U] 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
+        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 +
+            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)
+
+        unordered_map() except +
+        unordered_map(unordered_map&) except +
+        #unordered_map(key_compare&)
+        U& operator[](const T&)
+        #unordered_map& operator=(unordered_map&)
+        bint operator==(unordered_map&, unordered_map&)
+        bint operator!=(unordered_map&, unordered_map&)
+        bint operator<(unordered_map&, unordered_map&)
+        bint operator>(unordered_map&, unordered_map&)
+        bint operator<=(unordered_map&, unordered_map&)
+        bint operator>=(unordered_map&, unordered_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()
+        size_t size()
+        void swap(unordered_map&)
+        iterator upper_bound(const T&)
+        const_iterator const_upper_bound "upper_bound"(const T&)
+        #value_compare value_comp()
+        void max_load_factor(float)
+        float max_load_factor()
+        float load_factor()
+        void rehash(size_t)
+        void reserve(size_t)
+        size_t bucket_count()
+        size_t max_bucket_count()
+        size_t bucket_size(size_t)
+        size_t bucket(const T&)
+        # C++20
+        bint contains(const T&)
+
+    cdef cppclass unordered_multimap[T, U, HASH=*, PRED=*, ALLOCATOR=*]:
+        ctypedef T key_type
+        ctypedef U mapped_type
+        ctypedef pair[const T, U] 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 +
+            # correct would be value_type& but this does not work
+            # well with cython's code gen
+            pair[T, U]& operator*()
+            iterator operator++()
+            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 +
+            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++(int)
+            bint operator==(iterator)
+            bint operator==(const_iterator)
+            bint operator!=(iterator)
+            bint operator!=(const_iterator)
+
+        unordered_multimap() except +
+        unordered_multimap(const unordered_multimap&) except +
+        #unordered_multimap(key_compare&)
+        #unordered_map& operator=(unordered_multimap&)
+        bint operator==(const unordered_multimap&, const unordered_multimap&)
+        bint operator!=(const unordered_multimap&, const unordered_multimap&)
+        bint operator<(const unordered_multimap&, const unordered_multimap&)
+        bint operator>(const unordered_multimap&, const unordered_multimap&)
+        bint operator<=(const unordered_multimap&, const unordered_multimap&)
+        bint operator>=(const unordered_multimap&, const unordered_multimap&)
+        iterator begin()
+        const_iterator const_begin "begin"()
+        const_iterator cbegin()
+        #local_iterator begin(size_t)
+        #const_local_iterator const_begin "begin"(size_t)
+        void clear()
+        size_t count(const T&)
+        bint empty()
+        iterator end()
+        const_iterator const_end "end"()
+        const_iterator cend()
+        #local_iterator end(size_t)
+        #const_local_iterator const_end "end"(size_t)
+        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()
+        size_t size()
+        void swap(unordered_multimap&)
+        iterator upper_bound(const T&)
+        const_iterator const_upper_bound "upper_bound"(const T&)
+        #value_compare value_comp()
+        void max_load_factor(float)
+        float max_load_factor()
+        float load_factor()
+        void rehash(size_t)
+        void reserve(size_t)
+        size_t bucket_count()
+        size_t max_bucket_count()
+        size_t bucket_size(size_t)
+        size_t bucket(const T&)
+        # C++20
+        bint contains(const T&)

Cython/Includes/libcpp/unordered_set.pxd

@@ -0,0 +1,152 @@
+from .utility cimport pair
+
+cdef extern from "<unordered_set>" namespace "std" nogil:
+    cdef cppclass unordered_set[T,HASH=*,PRED=*,ALLOCATOR=*]:
+        ctypedef T value_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 +
+            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)
+
+        unordered_set() except +
+        unordered_set(unordered_set&) except +
+        #unordered_set& operator=(unordered_set&)
+        bint operator==(unordered_set&, unordered_set&)
+        bint operator!=(unordered_set&, unordered_set&)
+        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 T&) except +
+        iterator insert(const_iterator, const T&) except +
+        void insert[InputIt](InputIt, InputIt) except +
+        size_t max_size()
+        size_t size()
+        void swap(unordered_set&)
+        #value_compare value_comp()
+        void max_load_factor(float)
+        float max_load_factor()
+        float load_factor()
+        void rehash(size_t)
+        void reserve(size_t)
+        size_t bucket_count()
+        size_t max_bucket_count()
+        size_t bucket_size(size_t)
+        size_t bucket(const T&)
+        # C++20
+        bint contains(const T&)
+
+    cdef cppclass unordered_multiset[T,HASH=*,PRED=*,ALLOCATOR=*]:
+        ctypedef T value_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++(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 +
+            operator=(iterator&) except +
+            const value_type& operator*()
+            const_iterator operator++()
+            const_iterator operator++(int)
+            bint operator==(iterator)
+            bint operator==(const_iterator)
+            bint operator!=(iterator)
+            bint operator!=(const_iterator)
+
+        unordered_multiset() except +
+        unordered_multiset(unordered_multiset&) except +
+        #unordered_multiset& operator=(unordered_multiset&)
+        bint operator==(unordered_multiset&, unordered_multiset&)
+        bint operator!=(unordered_multiset&, unordered_multiset&)
+        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 T&) except +
+        iterator insert(const_iterator, const T&) except +
+        void insert[InputIt](InputIt, InputIt) except +
+        size_t max_size()
+        size_t size()
+        void swap(unordered_multiset&)
+        #value_compare value_comp()
+        void max_load_factor(float)
+        float max_load_factor()
+        float load_factor()
+        void rehash(size_t)
+        void reserve(size_t)
+        size_t bucket_count()
+        size_t max_bucket_count()
+        size_t bucket_size(size_t)
+        size_t bucket(const T&)
+        # C++20
+        bint contains(const T&)

Cython/Includes/libcpp/utility.pxd

@@ -0,0 +1,30 @@
+cdef extern from "<utility>" namespace "std" nogil:
+    cdef cppclass pair[T, U]:
+        ctypedef T first_type
+        ctypedef U second_type
+        T first
+        U second
+        pair() except +
+        pair(pair&) except +
+        pair(T&, U&) except +
+        bint operator==(pair&, pair&)
+        bint operator!=(pair&, pair&)
+        bint operator<(pair&, pair&)
+        bint operator>(pair&, pair&)
+        bint operator<=(pair&, pair&)
+        bint operator>=(pair&, pair&)
+
+cdef extern from * namespace "cython_std" nogil:
+    """
+    #if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600)
+    // move should be defined for these versions of MSVC, but __cplusplus isn't set usefully
+    #include <type_traits>
+
+    namespace cython_std {
+    template <typename T> typename std::remove_reference<T>::type&& move(T& t) noexcept { return std::move(t); }
+    template <typename T> typename std::remove_reference<T>::type&& move(T&& t) noexcept { return std::move(t); }
+    }
+
+    #endif
+    """
+    cdef T move[T](T)