Add GIL-free string implementation

src/stdlib/_string.pxd

+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:
+
+        cppclass iterator:
+            iterator()
+            char& operator*()
+            iterator(iterator&)
+            iterator operator++()
+            iterator operator--()
+            bint operator==(iterator)
+            bint operator!=(iterator)
+
+        cppclass reverse_iterator:
+            char& operator*()
+            iterator operator++()
+            iterator operator--()
+            iterator operator+(size_t)
+            iterator operator-(size_t)
+            bint operator==(reverse_iterator)
+            bint operator!=(reverse_iterator)
+            bint operator<(reverse_iterator)
+            bint operator>(reverse_iterator)
+            bint operator<=(reverse_iterator)
+            bint operator>=(reverse_iterator)
+
+        cppclass const_iterator(iterator):
+            pass
+
+        cppclass const_reverse_iterator(reverse_iterator):
+            pass
+
+        string_view() except +
+        string_view(const string_view& s) except +
+        string_view(const char* s) except +
+        string_view(const char* s, size_t n) except +
+        string_view(iterator first, iterator last) except +
+
+        string_view& operator= (const string_view&)
+
+        iterator begin()
+        const_iterator const_begin "begin"()
+        iterator end()
+        const_iterator const_end "end"()
+        reverse_iterator rbegin()
+        const_reverse_iterator const_rbegin "rbegin"()
+        reverse_iterator rend()
+        const_reverse_iterator const_rend "rend"()
+
+        char* data()
+        size_t size()
+        size_t max_size()
+        size_t length()
+        void swap(string_view& other)
+        bint empty()
+
+        char& at(size_t pos) except +
+        char& operator[](size_t pos)
+        char& front()
+        char& back()
+        int compare(const string_view& s)
+        int compare(size_t pos, size_t len, const string_view& s) except +
+        int compare(size_t pos, size_t len, const string_view& s, size_t subpos, size_t sublen) except +
+        int compare(const char* s) except +
+        int compare(size_t pos, size_t len, const char* s) except +
+        int compare(size_t pos, size_t len, const char* s , size_t n) except +
+
+        size_t copy(char* s, size_t len, size_t pos) except +
+        size_t copy(char* s, size_t len) except +
+
+        size_t find(const string_view& s, size_t pos)
+        size_t find(const 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(const string_view&, size_t pos)
+        size_t rfind(const 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(const string_view&, size_t pos)
+        size_t find_first_of(const 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(const string_view& s, size_t pos)
+        size_t find_first_not_of(const 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(const string_view& s, size_t pos)
+        size_t find_last_of(const 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(const string_view& s, size_t pos)
+        size_t find_last_not_of(const 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()
+
+        bint operator==(const string_view&)
+        bint operator==(const char*)
+
+        bint operator!= (const string_view&)
+        bint operator!= (const char*)
+
+        bint operator< (const string_view&)
+        bint operator< (const char*)
+
+        bint operator> (const string_view&)
+        bint operator> (const char*)
+
+        bint operator<= (const string_view&)
+        bint operator<= (const char*)
+
+        bint operator>= (const string_view&)
+        bint operator>= (const char*)
+
+
+    cdef cppclass hash_string_view "std::hash<std::string_view>":
+        hash_string_view()
+        size_t operator() (const string_view&)
+
+
+
+cdef extern from "<string>" namespace "std" nogil:
+    cdef cppclass string:
+
+        cppclass iterator:
+            iterator()
+            char& operator*()
+            iterator(iterator&)
+            iterator operator++()
+            iterator operator--()
+            bint operator==(iterator)
+            bint operator!=(iterator)
+
+        cppclass reverse_iterator:
+            char& operator*()
+            iterator operator++()
+            iterator operator--()
+            iterator operator+(size_t)
+            iterator operator-(size_t)
+            bint operator==(reverse_iterator)
+            bint operator!=(reverse_iterator)
+            bint operator<(reverse_iterator)
+            bint operator>(reverse_iterator)
+            bint operator<=(reverse_iterator)
+            bint operator>=(reverse_iterator)
+
+        cppclass const_iterator(iterator):
+            pass
+
+        cppclass const_reverse_iterator(reverse_iterator):
+            pass
+
+        string() except +
+        string(const string& s) except +
+        string(const string& s, size_t pos) except +
+        string(const string& s, size_t pos, size_t len) except +
+        string(const char* s) except +
+        string(const char* s, size_t n) except +
+        string(size_t n, char c) except +
+        string(iterator first, iterator last) except +
+
+        iterator begin()
+        const_iterator const_begin "begin"()
+        iterator end()
+        const_iterator const_end "end"()
+        reverse_iterator rbegin()
+        const_reverse_iterator const_rbegin "rbegin"()
+        reverse_iterator rend()
+        const_reverse_iterator const_rend "rend"()
+
+        const char* c_str()
+        const char* data()
+        size_t size()
+        size_t max_size()
+        size_t length()
+        void resize(size_t) except +
+        void resize(size_t, char) except +
+        void shrink_to_fit() except +
+        void swap(string& other)
+        size_t capacity()
+        void reserve(size_t) except +
+        void clear()
+        bint empty()
+
+        iterator erase(iterator first, iterator last)
+        iterator erase(iterator p)
+        iterator erase(const_iterator first, const_iterator last)
+        iterator erase(const_iterator p)
+        string& erase(size_t pos, size_t len) except +
+        string& erase(size_t pos) except +
+        string& erase() except +
+
+        char& at(size_t pos) except +
+        char& operator[](size_t pos)
+        char& front()
+        char& back()
+        int compare(const string& s)
+        int compare(size_t pos, size_t len, const string& s) except +
+        int compare(size_t pos, size_t len, const string& s, size_t subpos, size_t sublen) except +
+        int compare(const char* s) except +
+        int compare(size_t pos, size_t len, const char* s) except +
+        int compare(size_t pos, size_t len, const char* s , size_t n) except +
+
+        string& append(const string& s) except +
+        string& append(const string& s, size_t subpos, size_t sublen) except +
+        string& append(const char* s) except +
+        string& append(const char* s, size_t n) except +
+        string& append(size_t n, char c) except +
+
+        void push_back(char c) except +
+        void pop_back()
+
+        string& assign(const string& s) except +
+        string& assign(const string& s, size_t subpos, size_t sublen) except +
+        string& assign(const char* s, size_t n) except +
+        string& assign(const char* s) except +
+        string& assign(size_t n, char c) except +
+
+        string& insert(size_t pos, const string& s, size_t subpos, size_t sublen) except +
+        string& insert(size_t pos, const string& s) except +
+        string& insert(size_t pos, const char* s, size_t n) except +
+        string& insert(size_t pos, const char* s) except +
+        string& insert(size_t pos, size_t n, char c) except +
+        void insert(iterator p, size_t n, char c) except +
+        iterator insert(iterator p, char c) except +
+
+        size_t copy(char* s, size_t len, size_t pos) except +
+        size_t copy(char* s, size_t len) except +
+
+        size_t find(const string& s, size_t pos)
+        size_t find(const string& 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(const string&, size_t pos)
+        size_t rfind(const string&)
+        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(const string&, size_t pos)
+        size_t find_first_of(const string&)
+        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(const string& s, size_t pos)
+        size_t find_first_not_of(const string& 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(const string& s, size_t pos)
+        size_t find_last_of(const string& 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(const string& s, size_t pos)
+        size_t find_last_not_of(const string& 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 substr(size_t pos, size_t len) except +
+        string substr(size_t pos) except +
+        string substr()
+
+        #string& operator= (const string&)
+        #string& operator= (const char*)
+        #string& operator= (char)
+
+        string operator+ (const string&) except +
+        string operator+ (const char*) except +
+
+        bint operator==(const string&)
+        bint operator==(const char*)
+
+        bint operator!= (const string&)
+        bint operator!= (const char*)
+
+        bint operator< (const string&)
+        bint operator< (const char*)
+
+        bint operator> (const string&)
+        bint operator> (const char*)
+
+        bint operator<= (const string&)
+        bint operator<= (const char*)
+
+        bint operator>= (const string&)
+        bint operator>= (const char*)
+
+
+    cdef cppclass hash_string "std::hash<std::string>":
+        hash_string()
+        size_t operator() (const string&)
+
+
+    string to_string(int val) except +
+    string to_string(long val) except +
+    string to_string(long long val) except +
+    string to_string(unsigned val) except +
+    string to_string(size_t val) except +
+    string to_string(ssize_t val) except +
+    string to_string(unsigned long val) except +
+    string to_string(unsigned long long val) except +
+    string to_string(float val) except +
+    string to_string(double val) except +
+    string to_string(long double val) except +
+
+    int stoi(const string& s, size_t* idx, int base) except +
+    int stoi(const string& s, size_t* idx) except +
+    int stoi(const string& s)
+    long stol(const string& s, size_t* idx, int base) except +
+    long stol(const string& s, size_t* idx) except +
+    long stol(const string& s) except +
+    long long stoll(const string& s, size_t* idx, int base) except +
+    long long stoll(const string& s, size_t* idx) except +
+    long long stoll(const string& s) except +
+
+    unsigned long stoul(const string& s, size_t* idx, int base) except +
+    unsigned long stoul(const string& s, size_t* idx) except +
+    unsigned long stoul(const string& s) except +
+    unsigned long long stoull(const string& s, size_t* idx, int base) except +
+    unsigned long long stoull(const string& s, size_t* idx) except +
+    unsigned long long stoull(const string& s) except +
+
+    float stof(const string& s, size_t* idx) except +
+    float stof(const string& s) except +
+    double stod(const string& s, size_t* idx) except +
+    double stod(const string& s) except +
+    long double stold(const string& s, size_t* idx) except +
+    long double stold(const string& s) except +
+
+
+
+cdef extern from * nogil:
+    string move_string "static_cast<std::string&&>" (const string&)
+
+
+
+cdef extern from "<algorithm>" namespace "std" nogil:
+
+    OutputIt transform[InputIt, OutputIt, UnaryOp](
+        InputIt first1, InputIt last1, OutputIt d_first, UnaryOp unary_op) except +
+

src/stdlib/string.pxd

+from stdlib._string cimport string, string_view, hash_string, stoi, transform
+from libcythonplus.list cimport cyplist
+
+
+
+cdef extern from "<cctype>" namespace "std" nogil:
+
+    int isalnum(int c)
+    int isalpha(int c)
+    int isblank(int c)
+    int iscntrl(int c)
+    int isdigit(int c)
+    int isgraph(int c)
+    int islower(int c)
+    int isprint(int c)
+    int ispunct(int c)
+    int isspace(int c)
+    int isupper(int c)
+    int isxdigit(int c)
+    int tolower(int c)
+    int toupper(int c)
+
+
+
+cdef cypclass Str:
+    string _str
+
+    __init__(self, const char *s):
+        self._str = string(s)
+
+    size_t __len__(self):
+        return self._str.size()
+
+    bint __eq__(self, Str other):
+        return self._str == other._str
+
+    bint __ne__(self, Str other):
+        return self._str != other._str
+
+    size_t __hash__(self):
+        return hash_string()(self._str)
+
+    char __getitem__(self, int index) except 0:
+        cdef int end = self._str.size()
+        cdef int idx = index
+        if index < 0:
+            index = -index
+            idx = end - index
+        if index >= end:
+            with gil:
+                raise ValueError('index out of range')
+        return self._str[idx]
+
+    int find(self, Str s, size_t start=0, size_t stop=0):
+        if start < stop and stop <= self._str.size():
+            sw = string_view(self._str.data(), stop)
+            return sw.find(s._str.data(), start)
+        return self._str.find(s._str, start)
+
+    Str substr(self, int start=0, int stop=0) except NULL:
+        cdef int end = self._str.size()
+        cdef int tmp = stop
+        if stop <= 0:
+            stop = -stop
+            tmp = end - stop
+        if stop > end:
+            with gil:
+                raise ValueError('substr bounds out of range')
+        stop = tmp
+        if start < 0:
+            start = -start
+            if start > end:
+                with gil:
+                    raise ValueError('substr bounds out of range')
+            start = end - start
+        if start > stop:
+            with gil:
+                raise ValueError('substr bounds out of order')
+        cdef size_t size = stop - start
+        result = Str()
+        result._str = self._str.substr(start, size)
+        return result
+
+    cyplist[Str] split(self, Str delimiter=NULL) except NULL:
+        cdef cyplist[Str] result = cyplist[Str]()
+        cdef int start = 0
+        cdef int stop = 0
+        cdef int end = self._str.size()
+        if delimiter is NULL:
+            while True:
+                while stop < end and isspace(self._str[stop]):
+                    stop += 1
+                start = stop
+                if start >= end:
+                    return result
+                stop = start + 1
+                while stop < end and not isspace(self._str[stop]):
+                    stop += 1
+                result.append(self.substr(start, stop))
+        else:
+            while start < end:
+                stop = self.find(delimiter, start)
+                if stop == -1:
+                    stop = end
+                result.append(self.substr(start, stop))
+                start = stop + delimiter._str.size()
+            return result
+
+    Str join(self, cyplist[Str] strings) except NULL:
+        cdef Str joined = Str()
+        if strings is NULL or strings.__len__() == 0:
+            return joined
+        last = strings[strings.__len__() -1]
+        del strings[strings.__len__() - 1]
+        cdef int total = last._str.size()
+        for s in strings:
+            total += s._str.size()
+            total += self._str.size()
+        joined._str.reserve(total)
+        for s in strings:
+            joined._str.append(s._str)
+            joined._str.append(self._str)
+        joined._str.append(last._str)
+        return joined
+
+    Str lower(self):
+        cdef Str result = new Str()
+        result._str = self._str
+        transform(result._str.begin(), result._str.end(), result._str.begin(), tolower)
+        return result
+
+    Str __add__(self, Str other):
+        cdef Str result = new Str()
+        result._str = self._str + other._str
+        return result
+
+    int __int__(self) except +:
+        return stoi(self._str)
+
+    @staticmethod
+    const char * to_c_str(Str s):
+        if s is NULL:
+            return NULL
+        return s._str.data()
+