CppConvert.pyx 5.93 KB
Newer Older
1 2 3 4 5 6
# TODO: Figure out how many of the pass-by-value copies the compiler can eliminate.


#################### string.from_py ####################

cdef extern from *:
7
    cdef cppclass string "{{type}}":
8
        string()
9
        string(char* c_str, size_t size)
10
    cdef char* __Pyx_PyObject_AsStringAndSize(object, Py_ssize_t*) except NULL
11 12 13

@cname("{{cname}}")
cdef string {{cname}}(object o) except *:
14 15 16
    cdef Py_ssize_t length
    cdef char* data = __Pyx_PyObject_AsStringAndSize(o, &length)
    return string(data, length)
17 18


19 20 21 22 23 24 25 26 27
#################### string.to_py ####################

#cimport cython
#from libcpp.string cimport string
cdef extern from *:
    cdef cppclass string "{{type}}":
        char* data()
        size_t size()

28 29 30
{{for py_type in ['PyObject', 'PyUnicode', 'PyStr', 'PyBytes', 'PyByteArray']}}
cdef extern from *:
    cdef object __Pyx_{{py_type}}_FromStringAndSize(char*, size_t)
31

32 33 34 35
@cname("{{cname.replace("PyObject", py_type, 1)}}")
cdef inline object {{cname.replace("PyObject", py_type, 1)}}(const string& s):
    return __Pyx_{{py_type}}_FromStringAndSize(s.data(), s.size())
{{endfor}}
36 37


38 39 40 41 42 43 44
#################### vector.from_py ####################

cdef extern from *:
    cdef cppclass vector "std::vector" [T]:
        void push_back(T&)

@cname("{{cname}}")
45 46
cdef vector[X] {{cname}}(object o) except *:
    cdef vector[X] v
47
    for item in o:
48
        v.push_back(<X>item)
49 50 51 52 53 54 55 56 57 58 59
    return v


#################### vector.to_py ####################

cdef extern from *:
    cdef cppclass vector "const std::vector" [T]:
        size_t size()
        T& operator[](size_t)

@cname("{{cname}}")
60
cdef object {{cname}}(vector[X]& v):
61
    return [v[i] for i in range(v.size())]
62 63 64 65 66 67 68 69 70


#################### list.from_py ####################

cdef extern from *:
    cdef cppclass cpp_list "std::list" [T]:
        void push_back(T&)

@cname("{{cname}}")
Robert Bradshaw's avatar
Robert Bradshaw committed
71 72
cdef cpp_list[X] {{cname}}(object o) except *:
    cdef cpp_list[X] l
73
    for item in o:
74
        l.push_back(<X>item)
75 76 77 78 79
    return l


#################### list.to_py ####################

Robert Bradshaw's avatar
Robert Bradshaw committed
80 81
cimport cython

82 83 84 85 86 87 88 89 90 91
cdef extern from *:
    cdef cppclass cpp_list "std::list" [T]:
        cppclass const_iterator:
            T& operator*()
            const_iterator operator++()
            bint operator!=(const_iterator)
        const_iterator begin()
        const_iterator end()

@cname("{{cname}}")
Robert Bradshaw's avatar
Robert Bradshaw committed
92
cdef object {{cname}}(const cpp_list[X]& v):
93
    o = []
Robert Bradshaw's avatar
Robert Bradshaw committed
94 95
    cdef cpp_list[X].const_iterator iter = v.begin()
    while iter != v.end():
96
        o.append(cython.operator.dereference(iter))
97 98 99 100 101 102 103
        cython.operator.preincrement(iter)
    return o


#################### set.from_py ####################

cdef extern from *:
104
    cdef cppclass set "std::{{maybe_unordered}}set" [T]:
105 106 107
        void insert(T&)

@cname("{{cname}}")
108 109
cdef set[X] {{cname}}(object o) except *:
    cdef set[X] s
110
    for item in o:
111
        s.insert(<X>item)
112 113 114 115 116 117 118 119
    return s


#################### set.to_py ####################

cimport cython

cdef extern from *:
120
    cdef cppclass cpp_set "std::{{maybe_unordered}}set" [T]:
121 122 123 124 125 126 127 128
        cppclass const_iterator:
            T& operator*()
            const_iterator operator++()
            bint operator!=(const_iterator)
        const_iterator begin()
        const_iterator end()

@cname("{{cname}}")
Robert Bradshaw's avatar
Robert Bradshaw committed
129
cdef object {{cname}}(const cpp_set[X]& s):
130
    o = set()
131
    cdef cpp_set[X].const_iterator iter = s.begin()
132
    while iter != s.end():
133
        o.add(cython.operator.dereference(iter))
134 135 136 137 138 139 140
        cython.operator.preincrement(iter)
    return o

#################### pair.from_py ####################

cdef extern from *:
    cdef cppclass pair "std::pair" [T, U]:
141
        pair()
142 143 144
        pair(T&, U&)

@cname("{{cname}}")
145
cdef pair[X,Y] {{cname}}(object o) except *:
146
    x, y = o
147
    return pair[X,Y](<X>x, <Y>y)
148 149 150 151 152


#################### pair.to_py ####################

cdef extern from *:
Robert Bradshaw's avatar
Robert Bradshaw committed
153
    cdef cppclass pair "std::pair" [T, U]:
154 155 156 157
        T first
        U second

@cname("{{cname}}")
Robert Bradshaw's avatar
Robert Bradshaw committed
158
cdef object {{cname}}(const pair[X,Y]& p):
159
    return p.first, p.second
160 161 162 163 164 165 166


#################### map.from_py ####################

cdef extern from *:
    cdef cppclass pair "std::pair" [T, U]:
        pair(T&, U&)
167
    cdef cppclass map "std::{{maybe_unordered}}map" [T, U]:
168 169 170 171 172 173
        void insert(pair[T, U]&)
    cdef cppclass vector "std::vector" [T]:
        pass


@cname("{{cname}}")
Robert Bradshaw's avatar
Robert Bradshaw committed
174
cdef map[X,Y] {{cname}}(object o) except *:
175
    cdef dict d = o
Robert Bradshaw's avatar
Robert Bradshaw committed
176
    cdef map[X,Y] m
177
    for key, value in d.iteritems():
178
        m.insert(pair[X,Y](<X>key, <Y>value))
179 180 181 182 183 184 185 186 187 188
    return m


#################### map.to_py ####################
# TODO: Work out const so that this can take a const
# reference rather than pass by value.

cimport cython

cdef extern from *:
189
    cdef cppclass map "std::{{maybe_unordered}}map" [T, U]:
190 191 192
        cppclass value_type:
            T first
            U second
193
        cppclass const_iterator:
194
            value_type& operator*()
195 196 197 198
            const_iterator operator++()
            bint operator!=(const_iterator)
        const_iterator begin()
        const_iterator end()
199 200

@cname("{{cname}}")
201
cdef object {{cname}}(const map[X,Y]& s):
202
    o = {}
203 204
    cdef const map[X,Y].value_type *key_value
    cdef map[X,Y].const_iterator iter = s.begin()
205 206
    while iter != s.end():
        key_value = &cython.operator.dereference(iter)
207
        o[key_value.first] = key_value.second
208 209
        cython.operator.preincrement(iter)
    return o
210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237


#################### complex.from_py ####################

cdef extern from *:
    cdef cppclass std_complex "std::complex" [T]:
        std_complex()
        std_complex(T, T) except +

@cname("{{cname}}")
cdef std_complex[X] {{cname}}(object o) except *:
    cdef double complex z = o
    return std_complex[X](<X>z.real, <X>z.imag)


#################### complex.to_py ####################

cdef extern from *:
    cdef cppclass std_complex "std::complex" [T]:
        X real()
        X imag()

@cname("{{cname}}")
cdef object {{cname}}(const std_complex[X]& z):
    cdef double complex tmp
    tmp.real = <double>z.real()
    tmp.imag = <double>z.imag()
    return tmp